xref: /dports/games/pokerth/pokerth-1.1.2-rc/src/third_party/protobuf/pokerth.pb.cc

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "pokerth.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

void protobuf_ShutdownFile_pokerth_2eproto() {
  delete NetGameInfo::default_instance_;
  delete PlayerResult::default_instance_;
  delete AnnounceMessage::default_instance_;
  delete AnnounceMessage_Version::default_instance_;
  delete InitMessage::default_instance_;
  delete AuthServerChallengeMessage::default_instance_;
  delete AuthClientResponseMessage::default_instance_;
  delete AuthServerVerificationMessage::default_instance_;
  delete InitAckMessage::default_instance_;
  delete AvatarRequestMessage::default_instance_;
  delete AvatarHeaderMessage::default_instance_;
  delete AvatarDataMessage::default_instance_;
  delete AvatarEndMessage::default_instance_;
  delete UnknownAvatarMessage::default_instance_;
  delete PlayerListMessage::default_instance_;
  delete GameListNewMessage::default_instance_;
  delete GameListUpdateMessage::default_instance_;
  delete GameListPlayerJoinedMessage::default_instance_;
  delete GameListPlayerLeftMessage::default_instance_;
  delete GameListSpectatorJoinedMessage::default_instance_;
  delete GameListSpectatorLeftMessage::default_instance_;
  delete GameListAdminChangedMessage::default_instance_;
  delete PlayerInfoRequestMessage::default_instance_;
  delete PlayerInfoReplyMessage::default_instance_;
  delete PlayerInfoReplyMessage_PlayerInfoData::default_instance_;
  delete PlayerInfoReplyMessage_PlayerInfoData_AvatarData::default_instance_;
  delete SubscriptionRequestMessage::default_instance_;
  delete JoinExistingGameMessage::default_instance_;
  delete JoinNewGameMessage::default_instance_;
  delete RejoinExistingGameMessage::default_instance_;
  delete JoinGameAckMessage::default_instance_;
  delete JoinGameFailedMessage::default_instance_;
  delete GamePlayerJoinedMessage::default_instance_;
  delete GamePlayerLeftMessage::default_instance_;
  delete GameSpectatorJoinedMessage::default_instance_;
  delete GameSpectatorLeftMessage::default_instance_;
  delete GameAdminChangedMessage::default_instance_;
  delete RemovedFromGameMessage::default_instance_;
  delete KickPlayerRequestMessage::default_instance_;
  delete LeaveGameRequestMessage::default_instance_;
  delete InvitePlayerToGameMessage::default_instance_;
  delete InviteNotifyMessage::default_instance_;
  delete RejectGameInvitationMessage::default_instance_;
  delete RejectInvNotifyMessage::default_instance_;
  delete StartEventMessage::default_instance_;
  delete StartEventAckMessage::default_instance_;
  delete GameStartInitialMessage::default_instance_;
  delete GameStartRejoinMessage::default_instance_;
  delete GameStartRejoinMessage_RejoinPlayerData::default_instance_;
  delete HandStartMessage::default_instance_;
  delete HandStartMessage_PlainCards::default_instance_;
  delete PlayersTurnMessage::default_instance_;
  delete MyActionRequestMessage::default_instance_;
  delete YourActionRejectedMessage::default_instance_;
  delete PlayersActionDoneMessage::default_instance_;
  delete DealFlopCardsMessage::default_instance_;
  delete DealTurnCardMessage::default_instance_;
  delete DealRiverCardMessage::default_instance_;
  delete AllInShowCardsMessage::default_instance_;
  delete AllInShowCardsMessage_PlayerAllIn::default_instance_;
  delete EndOfHandShowCardsMessage::default_instance_;
  delete EndOfHandHideCardsMessage::default_instance_;
  delete ShowMyCardsRequestMessage::default_instance_;
  delete AfterHandShowCardsMessage::default_instance_;
  delete EndOfGameMessage::default_instance_;
  delete PlayerIdChangedMessage::default_instance_;
  delete AskKickPlayerMessage::default_instance_;
  delete AskKickDeniedMessage::default_instance_;
  delete StartKickPetitionMessage::default_instance_;
  delete VoteKickRequestMessage::default_instance_;
  delete VoteKickReplyMessage::default_instance_;
  delete KickPetitionUpdateMessage::default_instance_;
  delete EndKickPetitionMessage::default_instance_;
  delete StatisticsMessage::default_instance_;
  delete StatisticsMessage_StatisticsData::default_instance_;
  delete ChatRequestMessage::default_instance_;
  delete ChatMessage::default_instance_;
  delete ChatRejectMessage::default_instance_;
  delete DialogMessage::default_instance_;
  delete TimeoutWarningMessage::default_instance_;
  delete ResetTimeoutMessage::default_instance_;
  delete ReportAvatarMessage::default_instance_;
  delete ReportAvatarAckMessage::default_instance_;
  delete ReportGameMessage::default_instance_;
  delete ReportGameAckMessage::default_instance_;
  delete ErrorMessage::default_instance_;
  delete AdminRemoveGameMessage::default_instance_;
  delete AdminRemoveGameAckMessage::default_instance_;
  delete AdminBanPlayerMessage::default_instance_;
  delete AdminBanPlayerAckMessage::default_instance_;
  delete PokerTHMessage::default_instance_;
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
void protobuf_AddDesc_pokerth_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#else
void protobuf_AddDesc_pokerth_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#endif
  NetGameInfo::default_instance_ = new NetGameInfo();
  PlayerResult::default_instance_ = new PlayerResult();
  AnnounceMessage::default_instance_ = new AnnounceMessage();
  AnnounceMessage_Version::default_instance_ = new AnnounceMessage_Version();
  InitMessage::default_instance_ = new InitMessage();
  AuthServerChallengeMessage::default_instance_ = new AuthServerChallengeMessage();
  AuthClientResponseMessage::default_instance_ = new AuthClientResponseMessage();
  AuthServerVerificationMessage::default_instance_ = new AuthServerVerificationMessage();
  InitAckMessage::default_instance_ = new InitAckMessage();
  AvatarRequestMessage::default_instance_ = new AvatarRequestMessage();
  AvatarHeaderMessage::default_instance_ = new AvatarHeaderMessage();
  AvatarDataMessage::default_instance_ = new AvatarDataMessage();
  AvatarEndMessage::default_instance_ = new AvatarEndMessage();
  UnknownAvatarMessage::default_instance_ = new UnknownAvatarMessage();
  PlayerListMessage::default_instance_ = new PlayerListMessage();
  GameListNewMessage::default_instance_ = new GameListNewMessage();
  GameListUpdateMessage::default_instance_ = new GameListUpdateMessage();
  GameListPlayerJoinedMessage::default_instance_ = new GameListPlayerJoinedMessage();
  GameListPlayerLeftMessage::default_instance_ = new GameListPlayerLeftMessage();
  GameListSpectatorJoinedMessage::default_instance_ = new GameListSpectatorJoinedMessage();
  GameListSpectatorLeftMessage::default_instance_ = new GameListSpectatorLeftMessage();
  GameListAdminChangedMessage::default_instance_ = new GameListAdminChangedMessage();
  PlayerInfoRequestMessage::default_instance_ = new PlayerInfoRequestMessage();
  PlayerInfoReplyMessage::default_instance_ = new PlayerInfoReplyMessage();
  PlayerInfoReplyMessage_PlayerInfoData::default_instance_ = new PlayerInfoReplyMessage_PlayerInfoData();
  PlayerInfoReplyMessage_PlayerInfoData_AvatarData::default_instance_ = new PlayerInfoReplyMessage_PlayerInfoData_AvatarData();
  SubscriptionRequestMessage::default_instance_ = new SubscriptionRequestMessage();
  JoinExistingGameMessage::default_instance_ = new JoinExistingGameMessage();
  JoinNewGameMessage::default_instance_ = new JoinNewGameMessage();
  RejoinExistingGameMessage::default_instance_ = new RejoinExistingGameMessage();
  JoinGameAckMessage::default_instance_ = new JoinGameAckMessage();
  JoinGameFailedMessage::default_instance_ = new JoinGameFailedMessage();
  GamePlayerJoinedMessage::default_instance_ = new GamePlayerJoinedMessage();
  GamePlayerLeftMessage::default_instance_ = new GamePlayerLeftMessage();
  GameSpectatorJoinedMessage::default_instance_ = new GameSpectatorJoinedMessage();
  GameSpectatorLeftMessage::default_instance_ = new GameSpectatorLeftMessage();
  GameAdminChangedMessage::default_instance_ = new GameAdminChangedMessage();
  RemovedFromGameMessage::default_instance_ = new RemovedFromGameMessage();
  KickPlayerRequestMessage::default_instance_ = new KickPlayerRequestMessage();
  LeaveGameRequestMessage::default_instance_ = new LeaveGameRequestMessage();
  InvitePlayerToGameMessage::default_instance_ = new InvitePlayerToGameMessage();
  InviteNotifyMessage::default_instance_ = new InviteNotifyMessage();
  RejectGameInvitationMessage::default_instance_ = new RejectGameInvitationMessage();
  RejectInvNotifyMessage::default_instance_ = new RejectInvNotifyMessage();
  StartEventMessage::default_instance_ = new StartEventMessage();
  StartEventAckMessage::default_instance_ = new StartEventAckMessage();
  GameStartInitialMessage::default_instance_ = new GameStartInitialMessage();
  GameStartRejoinMessage::default_instance_ = new GameStartRejoinMessage();
  GameStartRejoinMessage_RejoinPlayerData::default_instance_ = new GameStartRejoinMessage_RejoinPlayerData();
  HandStartMessage::default_instance_ = new HandStartMessage();
  HandStartMessage_PlainCards::default_instance_ = new HandStartMessage_PlainCards();
  PlayersTurnMessage::default_instance_ = new PlayersTurnMessage();
  MyActionRequestMessage::default_instance_ = new MyActionRequestMessage();
  YourActionRejectedMessage::default_instance_ = new YourActionRejectedMessage();
  PlayersActionDoneMessage::default_instance_ = new PlayersActionDoneMessage();
  DealFlopCardsMessage::default_instance_ = new DealFlopCardsMessage();
  DealTurnCardMessage::default_instance_ = new DealTurnCardMessage();
  DealRiverCardMessage::default_instance_ = new DealRiverCardMessage();
  AllInShowCardsMessage::default_instance_ = new AllInShowCardsMessage();
  AllInShowCardsMessage_PlayerAllIn::default_instance_ = new AllInShowCardsMessage_PlayerAllIn();
  EndOfHandShowCardsMessage::default_instance_ = new EndOfHandShowCardsMessage();
  EndOfHandHideCardsMessage::default_instance_ = new EndOfHandHideCardsMessage();
  ShowMyCardsRequestMessage::default_instance_ = new ShowMyCardsRequestMessage();
  AfterHandShowCardsMessage::default_instance_ = new AfterHandShowCardsMessage();
  EndOfGameMessage::default_instance_ = new EndOfGameMessage();
  PlayerIdChangedMessage::default_instance_ = new PlayerIdChangedMessage();
  AskKickPlayerMessage::default_instance_ = new AskKickPlayerMessage();
  AskKickDeniedMessage::default_instance_ = new AskKickDeniedMessage();
  StartKickPetitionMessage::default_instance_ = new StartKickPetitionMessage();
  VoteKickRequestMessage::default_instance_ = new VoteKickRequestMessage();
  VoteKickReplyMessage::default_instance_ = new VoteKickReplyMessage();
  KickPetitionUpdateMessage::default_instance_ = new KickPetitionUpdateMessage();
  EndKickPetitionMessage::default_instance_ = new EndKickPetitionMessage();
  StatisticsMessage::default_instance_ = new StatisticsMessage();
  StatisticsMessage_StatisticsData::default_instance_ = new StatisticsMessage_StatisticsData();
  ChatRequestMessage::default_instance_ = new ChatRequestMessage();
  ChatMessage::default_instance_ = new ChatMessage();
  ChatRejectMessage::default_instance_ = new ChatRejectMessage();
  DialogMessage::default_instance_ = new DialogMessage();
  TimeoutWarningMessage::default_instance_ = new TimeoutWarningMessage();
  ResetTimeoutMessage::default_instance_ = new ResetTimeoutMessage();
  ReportAvatarMessage::default_instance_ = new ReportAvatarMessage();
  ReportAvatarAckMessage::default_instance_ = new ReportAvatarAckMessage();
  ReportGameMessage::default_instance_ = new ReportGameMessage();
  ReportGameAckMessage::default_instance_ = new ReportGameAckMessage();
  ErrorMessage::default_instance_ = new ErrorMessage();
  AdminRemoveGameMessage::default_instance_ = new AdminRemoveGameMessage();
  AdminRemoveGameAckMessage::default_instance_ = new AdminRemoveGameAckMessage();
  AdminBanPlayerMessage::default_instance_ = new AdminBanPlayerMessage();
  AdminBanPlayerAckMessage::default_instance_ = new AdminBanPlayerAckMessage();
  PokerTHMessage::default_instance_ = new PokerTHMessage();
  NetGameInfo::default_instance_->InitAsDefaultInstance();
  PlayerResult::default_instance_->InitAsDefaultInstance();
  AnnounceMessage::default_instance_->InitAsDefaultInstance();
  AnnounceMessage_Version::default_instance_->InitAsDefaultInstance();
  InitMessage::default_instance_->InitAsDefaultInstance();
  AuthServerChallengeMessage::default_instance_->InitAsDefaultInstance();
  AuthClientResponseMessage::default_instance_->InitAsDefaultInstance();
  AuthServerVerificationMessage::default_instance_->InitAsDefaultInstance();
  InitAckMessage::default_instance_->InitAsDefaultInstance();
  AvatarRequestMessage::default_instance_->InitAsDefaultInstance();
  AvatarHeaderMessage::default_instance_->InitAsDefaultInstance();
  AvatarDataMessage::default_instance_->InitAsDefaultInstance();
  AvatarEndMessage::default_instance_->InitAsDefaultInstance();
  UnknownAvatarMessage::default_instance_->InitAsDefaultInstance();
  PlayerListMessage::default_instance_->InitAsDefaultInstance();
  GameListNewMessage::default_instance_->InitAsDefaultInstance();
  GameListUpdateMessage::default_instance_->InitAsDefaultInstance();
  GameListPlayerJoinedMessage::default_instance_->InitAsDefaultInstance();
  GameListPlayerLeftMessage::default_instance_->InitAsDefaultInstance();
  GameListSpectatorJoinedMessage::default_instance_->InitAsDefaultInstance();
  GameListSpectatorLeftMessage::default_instance_->InitAsDefaultInstance();
  GameListAdminChangedMessage::default_instance_->InitAsDefaultInstance();
  PlayerInfoRequestMessage::default_instance_->InitAsDefaultInstance();
  PlayerInfoReplyMessage::default_instance_->InitAsDefaultInstance();
  PlayerInfoReplyMessage_PlayerInfoData::default_instance_->InitAsDefaultInstance();
  PlayerInfoReplyMessage_PlayerInfoData_AvatarData::default_instance_->InitAsDefaultInstance();
  SubscriptionRequestMessage::default_instance_->InitAsDefaultInstance();
  JoinExistingGameMessage::default_instance_->InitAsDefaultInstance();
  JoinNewGameMessage::default_instance_->InitAsDefaultInstance();
  RejoinExistingGameMessage::default_instance_->InitAsDefaultInstance();
  JoinGameAckMessage::default_instance_->InitAsDefaultInstance();
  JoinGameFailedMessage::default_instance_->InitAsDefaultInstance();
  GamePlayerJoinedMessage::default_instance_->InitAsDefaultInstance();
  GamePlayerLeftMessage::default_instance_->InitAsDefaultInstance();
  GameSpectatorJoinedMessage::default_instance_->InitAsDefaultInstance();
  GameSpectatorLeftMessage::default_instance_->InitAsDefaultInstance();
  GameAdminChangedMessage::default_instance_->InitAsDefaultInstance();
  RemovedFromGameMessage::default_instance_->InitAsDefaultInstance();
  KickPlayerRequestMessage::default_instance_->InitAsDefaultInstance();
  LeaveGameRequestMessage::default_instance_->InitAsDefaultInstance();
  InvitePlayerToGameMessage::default_instance_->InitAsDefaultInstance();
  InviteNotifyMessage::default_instance_->InitAsDefaultInstance();
  RejectGameInvitationMessage::default_instance_->InitAsDefaultInstance();
  RejectInvNotifyMessage::default_instance_->InitAsDefaultInstance();
  StartEventMessage::default_instance_->InitAsDefaultInstance();
  StartEventAckMessage::default_instance_->InitAsDefaultInstance();
  GameStartInitialMessage::default_instance_->InitAsDefaultInstance();
  GameStartRejoinMessage::default_instance_->InitAsDefaultInstance();
  GameStartRejoinMessage_RejoinPlayerData::default_instance_->InitAsDefaultInstance();
  HandStartMessage::default_instance_->InitAsDefaultInstance();
  HandStartMessage_PlainCards::default_instance_->InitAsDefaultInstance();
  PlayersTurnMessage::default_instance_->InitAsDefaultInstance();
  MyActionRequestMessage::default_instance_->InitAsDefaultInstance();
  YourActionRejectedMessage::default_instance_->InitAsDefaultInstance();
  PlayersActionDoneMessage::default_instance_->InitAsDefaultInstance();
  DealFlopCardsMessage::default_instance_->InitAsDefaultInstance();
  DealTurnCardMessage::default_instance_->InitAsDefaultInstance();
  DealRiverCardMessage::default_instance_->InitAsDefaultInstance();
  AllInShowCardsMessage::default_instance_->InitAsDefaultInstance();
  AllInShowCardsMessage_PlayerAllIn::default_instance_->InitAsDefaultInstance();
  EndOfHandShowCardsMessage::default_instance_->InitAsDefaultInstance();
  EndOfHandHideCardsMessage::default_instance_->InitAsDefaultInstance();
  ShowMyCardsRequestMessage::default_instance_->InitAsDefaultInstance();
  AfterHandShowCardsMessage::default_instance_->InitAsDefaultInstance();
  EndOfGameMessage::default_instance_->InitAsDefaultInstance();
  PlayerIdChangedMessage::default_instance_->InitAsDefaultInstance();
  AskKickPlayerMessage::default_instance_->InitAsDefaultInstance();
  AskKickDeniedMessage::default_instance_->InitAsDefaultInstance();
  StartKickPetitionMessage::default_instance_->InitAsDefaultInstance();
  VoteKickRequestMessage::default_instance_->InitAsDefaultInstance();
  VoteKickReplyMessage::default_instance_->InitAsDefaultInstance();
  KickPetitionUpdateMessage::default_instance_->InitAsDefaultInstance();
  EndKickPetitionMessage::default_instance_->InitAsDefaultInstance();
  StatisticsMessage::default_instance_->InitAsDefaultInstance();
  StatisticsMessage_StatisticsData::default_instance_->InitAsDefaultInstance();
  ChatRequestMessage::default_instance_->InitAsDefaultInstance();
  ChatMessage::default_instance_->InitAsDefaultInstance();
  ChatRejectMessage::default_instance_->InitAsDefaultInstance();
  DialogMessage::default_instance_->InitAsDefaultInstance();
  TimeoutWarningMessage::default_instance_->InitAsDefaultInstance();
  ResetTimeoutMessage::default_instance_->InitAsDefaultInstance();
  ReportAvatarMessage::default_instance_->InitAsDefaultInstance();
  ReportAvatarAckMessage::default_instance_->InitAsDefaultInstance();
  ReportGameMessage::default_instance_->InitAsDefaultInstance();
  ReportGameAckMessage::default_instance_->InitAsDefaultInstance();
  ErrorMessage::default_instance_->InitAsDefaultInstance();
  AdminRemoveGameMessage::default_instance_->InitAsDefaultInstance();
  AdminRemoveGameAckMessage::default_instance_->InitAsDefaultInstance();
  AdminBanPlayerMessage::default_instance_->InitAsDefaultInstance();
  AdminBanPlayerAckMessage::default_instance_->InitAsDefaultInstance();
  PokerTHMessage::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_pokerth_2eproto);
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_pokerth_2eproto_once_);
void protobuf_AddDesc_pokerth_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_pokerth_2eproto_once_,
                 &protobuf_AddDesc_pokerth_2eproto_impl);
}
#else
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_pokerth_2eproto {
  StaticDescriptorInitializer_pokerth_2eproto() {
    protobuf_AddDesc_pokerth_2eproto();
  }
} static_descriptor_initializer_pokerth_2eproto_;
#endif
bool NetGameMode_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

bool NetGameState_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

bool NetPlayerAction_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

bool NetPlayerState_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

bool NetPlayerInfoRights_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

bool NetAvatarType_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}


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

bool NetGameInfo_NetGameType_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const NetGameInfo_NetGameType NetGameInfo::normalGame;
const NetGameInfo_NetGameType NetGameInfo::registeredOnlyGame;
const NetGameInfo_NetGameType NetGameInfo::inviteOnlyGame;
const NetGameInfo_NetGameType NetGameInfo::rankingGame;
const NetGameInfo_NetGameType NetGameInfo::NetGameType_MIN;
const NetGameInfo_NetGameType NetGameInfo::NetGameType_MAX;
const int NetGameInfo::NetGameType_ARRAYSIZE;
#endif  // _MSC_VER
bool NetGameInfo_RaiseIntervalMode_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const NetGameInfo_RaiseIntervalMode NetGameInfo::raiseOnHandNum;
const NetGameInfo_RaiseIntervalMode NetGameInfo::raiseOnMinutes;
const NetGameInfo_RaiseIntervalMode NetGameInfo::RaiseIntervalMode_MIN;
const NetGameInfo_RaiseIntervalMode NetGameInfo::RaiseIntervalMode_MAX;
const int NetGameInfo::RaiseIntervalMode_ARRAYSIZE;
#endif  // _MSC_VER
bool NetGameInfo_EndRaiseMode_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const NetGameInfo_EndRaiseMode NetGameInfo::doubleBlinds;
const NetGameInfo_EndRaiseMode NetGameInfo::raiseByEndValue;
const NetGameInfo_EndRaiseMode NetGameInfo::keepLastBlind;
const NetGameInfo_EndRaiseMode NetGameInfo::EndRaiseMode_MIN;
const NetGameInfo_EndRaiseMode NetGameInfo::EndRaiseMode_MAX;
const int NetGameInfo::EndRaiseMode_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int NetGameInfo::kGameNameFieldNumber;
const int NetGameInfo::kNetGameTypeFieldNumber;
const int NetGameInfo::kMaxNumPlayersFieldNumber;
const int NetGameInfo::kRaiseIntervalModeFieldNumber;
const int NetGameInfo::kRaiseEveryHandsFieldNumber;
const int NetGameInfo::kRaiseEveryMinutesFieldNumber;
const int NetGameInfo::kEndRaiseModeFieldNumber;
const int NetGameInfo::kEndRaiseSmallBlindValueFieldNumber;
const int NetGameInfo::kProposedGuiSpeedFieldNumber;
const int NetGameInfo::kDelayBetweenHandsFieldNumber;
const int NetGameInfo::kPlayerActionTimeoutFieldNumber;
const int NetGameInfo::kFirstSmallBlindFieldNumber;
const int NetGameInfo::kStartMoneyFieldNumber;
const int NetGameInfo::kManualBlindsFieldNumber;
const int NetGameInfo::kAllowSpectatorsFieldNumber;
#endif  // !_MSC_VER

NetGameInfo::NetGameInfo()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:NetGameInfo)
}

void NetGameInfo::InitAsDefaultInstance() {
}

NetGameInfo::NetGameInfo(const NetGameInfo& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:NetGameInfo)
}

void NetGameInfo::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  gamename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  netgametype_ = 1;
  maxnumplayers_ = 0u;
  raiseintervalmode_ = 1;
  raiseeveryhands_ = 0u;
  raiseeveryminutes_ = 0u;
  endraisemode_ = 1;
  endraisesmallblindvalue_ = 0u;
  proposedguispeed_ = 0u;
  delaybetweenhands_ = 0u;
  playeractiontimeout_ = 0u;
  firstsmallblind_ = 0u;
  startmoney_ = 0u;
  allowspectators_ = true;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

NetGameInfo::~NetGameInfo() {
  // @@protoc_insertion_point(destructor:NetGameInfo)
  SharedDtor();
}

void NetGameInfo::SharedDtor() {
  if (gamename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete gamename_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void NetGameInfo::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const NetGameInfo& NetGameInfo::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

NetGameInfo* NetGameInfo::default_instance_ = NULL;

NetGameInfo* NetGameInfo::New() const {
  return new NetGameInfo;
}

void NetGameInfo::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<NetGameInfo*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 255) {
    ZR_(raiseeveryhands_, raiseeveryminutes_);
    if (has_gamename()) {
      if (gamename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        gamename_->clear();
      }
    }
    netgametype_ = 1;
    maxnumplayers_ = 0u;
    raiseintervalmode_ = 1;
    endraisemode_ = 1;
    endraisesmallblindvalue_ = 0u;
  }
  if (_has_bits_[8 / 32] & 24320) {
    ZR_(proposedguispeed_, startmoney_);
    allowspectators_ = true;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  manualblinds_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool NetGameInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:NetGameInfo)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string gameName = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_gamename()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_netGameType;
        break;
      }

      // required .NetGameInfo.NetGameType netGameType = 2;
      case 2: {
        if (tag == 16) {
         parse_netGameType:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetGameInfo_NetGameType_IsValid(value)) {
            set_netgametype(static_cast< ::NetGameInfo_NetGameType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_maxNumPlayers;
        break;
      }

      // required uint32 maxNumPlayers = 3;
      case 3: {
        if (tag == 24) {
         parse_maxNumPlayers:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &maxnumplayers_)));
          set_has_maxnumplayers();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_raiseIntervalMode;
        break;
      }

      // required .NetGameInfo.RaiseIntervalMode raiseIntervalMode = 4;
      case 4: {
        if (tag == 32) {
         parse_raiseIntervalMode:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetGameInfo_RaiseIntervalMode_IsValid(value)) {
            set_raiseintervalmode(static_cast< ::NetGameInfo_RaiseIntervalMode >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_raiseEveryHands;
        break;
      }

      // optional uint32 raiseEveryHands = 5;
      case 5: {
        if (tag == 40) {
         parse_raiseEveryHands:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &raiseeveryhands_)));
          set_has_raiseeveryhands();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_raiseEveryMinutes;
        break;
      }

      // optional uint32 raiseEveryMinutes = 6;
      case 6: {
        if (tag == 48) {
         parse_raiseEveryMinutes:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &raiseeveryminutes_)));
          set_has_raiseeveryminutes();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_endRaiseMode;
        break;
      }

      // required .NetGameInfo.EndRaiseMode endRaiseMode = 7;
      case 7: {
        if (tag == 56) {
         parse_endRaiseMode:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetGameInfo_EndRaiseMode_IsValid(value)) {
            set_endraisemode(static_cast< ::NetGameInfo_EndRaiseMode >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_endRaiseSmallBlindValue;
        break;
      }

      // optional uint32 endRaiseSmallBlindValue = 8;
      case 8: {
        if (tag == 64) {
         parse_endRaiseSmallBlindValue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &endraisesmallblindvalue_)));
          set_has_endraisesmallblindvalue();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_proposedGuiSpeed;
        break;
      }

      // required uint32 proposedGuiSpeed = 9;
      case 9: {
        if (tag == 72) {
         parse_proposedGuiSpeed:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &proposedguispeed_)));
          set_has_proposedguispeed();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(80)) goto parse_delayBetweenHands;
        break;
      }

      // required uint32 delayBetweenHands = 10;
      case 10: {
        if (tag == 80) {
         parse_delayBetweenHands:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &delaybetweenhands_)));
          set_has_delaybetweenhands();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(88)) goto parse_playerActionTimeout;
        break;
      }

      // required uint32 playerActionTimeout = 11;
      case 11: {
        if (tag == 88) {
         parse_playerActionTimeout:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playeractiontimeout_)));
          set_has_playeractiontimeout();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(96)) goto parse_firstSmallBlind;
        break;
      }

      // required uint32 firstSmallBlind = 12;
      case 12: {
        if (tag == 96) {
         parse_firstSmallBlind:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &firstsmallblind_)));
          set_has_firstsmallblind();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(104)) goto parse_startMoney;
        break;
      }

      // required uint32 startMoney = 13;
      case 13: {
        if (tag == 104) {
         parse_startMoney:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &startmoney_)));
          set_has_startmoney();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(114)) goto parse_manualBlinds;
        break;
      }

      // repeated uint32 manualBlinds = 14 [packed = true];
      case 14: {
        if (tag == 114) {
         parse_manualBlinds:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_manualblinds())));
        } else if (tag == 112) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 114, input, this->mutable_manualblinds())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(120)) goto parse_allowSpectators;
        break;
      }

      // optional bool allowSpectators = 15 [default = true];
      case 15: {
        if (tag == 120) {
         parse_allowSpectators:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &allowspectators_)));
          set_has_allowspectators();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:NetGameInfo)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:NetGameInfo)
  return false;
#undef DO_
}

void NetGameInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:NetGameInfo)
  // required string gameName = 1;
  if (has_gamename()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->gamename(), output);
  }

  // required .NetGameInfo.NetGameType netGameType = 2;
  if (has_netgametype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->netgametype(), output);
  }

  // required uint32 maxNumPlayers = 3;
  if (has_maxnumplayers()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->maxnumplayers(), output);
  }

  // required .NetGameInfo.RaiseIntervalMode raiseIntervalMode = 4;
  if (has_raiseintervalmode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->raiseintervalmode(), output);
  }

  // optional uint32 raiseEveryHands = 5;
  if (has_raiseeveryhands()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->raiseeveryhands(), output);
  }

  // optional uint32 raiseEveryMinutes = 6;
  if (has_raiseeveryminutes()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->raiseeveryminutes(), output);
  }

  // required .NetGameInfo.EndRaiseMode endRaiseMode = 7;
  if (has_endraisemode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      7, this->endraisemode(), output);
  }

  // optional uint32 endRaiseSmallBlindValue = 8;
  if (has_endraisesmallblindvalue()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->endraisesmallblindvalue(), output);
  }

  // required uint32 proposedGuiSpeed = 9;
  if (has_proposedguispeed()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->proposedguispeed(), output);
  }

  // required uint32 delayBetweenHands = 10;
  if (has_delaybetweenhands()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->delaybetweenhands(), output);
  }

  // required uint32 playerActionTimeout = 11;
  if (has_playeractiontimeout()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->playeractiontimeout(), output);
  }

  // required uint32 firstSmallBlind = 12;
  if (has_firstsmallblind()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(12, this->firstsmallblind(), output);
  }

  // required uint32 startMoney = 13;
  if (has_startmoney()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(13, this->startmoney(), output);
  }

  // repeated uint32 manualBlinds = 14 [packed = true];
  if (this->manualblinds_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(14, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_manualblinds_cached_byte_size_);
  }
  for (int i = 0; i < this->manualblinds_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
      this->manualblinds(i), output);
  }

  // optional bool allowSpectators = 15 [default = true];
  if (has_allowspectators()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->allowspectators(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:NetGameInfo)
}

int NetGameInfo::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string gameName = 1;
    if (has_gamename()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->gamename());
    }

    // required .NetGameInfo.NetGameType netGameType = 2;
    if (has_netgametype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->netgametype());
    }

    // required uint32 maxNumPlayers = 3;
    if (has_maxnumplayers()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->maxnumplayers());
    }

    // required .NetGameInfo.RaiseIntervalMode raiseIntervalMode = 4;
    if (has_raiseintervalmode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->raiseintervalmode());
    }

    // optional uint32 raiseEveryHands = 5;
    if (has_raiseeveryhands()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->raiseeveryhands());
    }

    // optional uint32 raiseEveryMinutes = 6;
    if (has_raiseeveryminutes()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->raiseeveryminutes());
    }

    // required .NetGameInfo.EndRaiseMode endRaiseMode = 7;
    if (has_endraisemode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->endraisemode());
    }

    // optional uint32 endRaiseSmallBlindValue = 8;
    if (has_endraisesmallblindvalue()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->endraisesmallblindvalue());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // required uint32 proposedGuiSpeed = 9;
    if (has_proposedguispeed()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->proposedguispeed());
    }

    // required uint32 delayBetweenHands = 10;
    if (has_delaybetweenhands()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->delaybetweenhands());
    }

    // required uint32 playerActionTimeout = 11;
    if (has_playeractiontimeout()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playeractiontimeout());
    }

    // required uint32 firstSmallBlind = 12;
    if (has_firstsmallblind()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->firstsmallblind());
    }

    // required uint32 startMoney = 13;
    if (has_startmoney()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->startmoney());
    }

    // optional bool allowSpectators = 15 [default = true];
    if (has_allowspectators()) {
      total_size += 1 + 1;
    }

  }
  // repeated uint32 manualBlinds = 14 [packed = true];
  {
    int data_size = 0;
    for (int i = 0; i < this->manualblinds_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->manualblinds(i));
    }
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _manualblinds_cached_byte_size_ = data_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void NetGameInfo::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const NetGameInfo*>(&from));
}

void NetGameInfo::MergeFrom(const NetGameInfo& from) {
  GOOGLE_CHECK_NE(&from, this);
  manualblinds_.MergeFrom(from.manualblinds_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gamename()) {
      set_gamename(from.gamename());
    }
    if (from.has_netgametype()) {
      set_netgametype(from.netgametype());
    }
    if (from.has_maxnumplayers()) {
      set_maxnumplayers(from.maxnumplayers());
    }
    if (from.has_raiseintervalmode()) {
      set_raiseintervalmode(from.raiseintervalmode());
    }
    if (from.has_raiseeveryhands()) {
      set_raiseeveryhands(from.raiseeveryhands());
    }
    if (from.has_raiseeveryminutes()) {
      set_raiseeveryminutes(from.raiseeveryminutes());
    }
    if (from.has_endraisemode()) {
      set_endraisemode(from.endraisemode());
    }
    if (from.has_endraisesmallblindvalue()) {
      set_endraisesmallblindvalue(from.endraisesmallblindvalue());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_proposedguispeed()) {
      set_proposedguispeed(from.proposedguispeed());
    }
    if (from.has_delaybetweenhands()) {
      set_delaybetweenhands(from.delaybetweenhands());
    }
    if (from.has_playeractiontimeout()) {
      set_playeractiontimeout(from.playeractiontimeout());
    }
    if (from.has_firstsmallblind()) {
      set_firstsmallblind(from.firstsmallblind());
    }
    if (from.has_startmoney()) {
      set_startmoney(from.startmoney());
    }
    if (from.has_allowspectators()) {
      set_allowspectators(from.allowspectators());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void NetGameInfo::CopyFrom(const NetGameInfo& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NetGameInfo::IsInitialized() const {
  if ((_has_bits_[0] & 0x00001f4f) != 0x00001f4f) return false;

  return true;
}

void NetGameInfo::Swap(NetGameInfo* other) {
  if (other != this) {
    std::swap(gamename_, other->gamename_);
    std::swap(netgametype_, other->netgametype_);
    std::swap(maxnumplayers_, other->maxnumplayers_);
    std::swap(raiseintervalmode_, other->raiseintervalmode_);
    std::swap(raiseeveryhands_, other->raiseeveryhands_);
    std::swap(raiseeveryminutes_, other->raiseeveryminutes_);
    std::swap(endraisemode_, other->endraisemode_);
    std::swap(endraisesmallblindvalue_, other->endraisesmallblindvalue_);
    std::swap(proposedguispeed_, other->proposedguispeed_);
    std::swap(delaybetweenhands_, other->delaybetweenhands_);
    std::swap(playeractiontimeout_, other->playeractiontimeout_);
    std::swap(firstsmallblind_, other->firstsmallblind_);
    std::swap(startmoney_, other->startmoney_);
    manualblinds_.Swap(&other->manualblinds_);
    std::swap(allowspectators_, other->allowspectators_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string NetGameInfo::GetTypeName() const {
  return "NetGameInfo";
}


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

#ifndef _MSC_VER
const int PlayerResult::kPlayerIdFieldNumber;
const int PlayerResult::kResultCard1FieldNumber;
const int PlayerResult::kResultCard2FieldNumber;
const int PlayerResult::kBestHandPositionFieldNumber;
const int PlayerResult::kMoneyWonFieldNumber;
const int PlayerResult::kPlayerMoneyFieldNumber;
const int PlayerResult::kCardsValueFieldNumber;
#endif  // !_MSC_VER

PlayerResult::PlayerResult()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PlayerResult)
}

void PlayerResult::InitAsDefaultInstance() {
}

PlayerResult::PlayerResult(const PlayerResult& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PlayerResult)
}

void PlayerResult::SharedCtor() {
  _cached_size_ = 0;
  playerid_ = 0u;
  resultcard1_ = 0u;
  resultcard2_ = 0u;
  moneywon_ = 0u;
  playermoney_ = 0u;
  cardsvalue_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PlayerResult::~PlayerResult() {
  // @@protoc_insertion_point(destructor:PlayerResult)
  SharedDtor();
}

void PlayerResult::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void PlayerResult::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PlayerResult& PlayerResult::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

PlayerResult* PlayerResult::default_instance_ = NULL;

PlayerResult* PlayerResult::New() const {
  return new PlayerResult;
}

void PlayerResult::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<PlayerResult*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 119) {
    ZR_(playerid_, resultcard1_);
    ZR_(resultcard2_, cardsvalue_);
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  besthandposition_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PlayerResult::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PlayerResult)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 playerId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_resultCard1;
        break;
      }

      // required uint32 resultCard1 = 2;
      case 2: {
        if (tag == 16) {
         parse_resultCard1:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &resultcard1_)));
          set_has_resultcard1();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_resultCard2;
        break;
      }

      // required uint32 resultCard2 = 3;
      case 3: {
        if (tag == 24) {
         parse_resultCard2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &resultcard2_)));
          set_has_resultcard2();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_bestHandPosition;
        break;
      }

      // repeated uint32 bestHandPosition = 4 [packed = true];
      case 4: {
        if (tag == 34) {
         parse_bestHandPosition:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_besthandposition())));
        } else if (tag == 32) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 34, input, this->mutable_besthandposition())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_moneyWon;
        break;
      }

      // required uint32 moneyWon = 5;
      case 5: {
        if (tag == 40) {
         parse_moneyWon:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &moneywon_)));
          set_has_moneywon();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_playerMoney;
        break;
      }

      // required uint32 playerMoney = 6;
      case 6: {
        if (tag == 48) {
         parse_playerMoney:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playermoney_)));
          set_has_playermoney();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_cardsValue;
        break;
      }

      // optional uint32 cardsValue = 7;
      case 7: {
        if (tag == 56) {
         parse_cardsValue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &cardsvalue_)));
          set_has_cardsvalue();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PlayerResult)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PlayerResult)
  return false;
#undef DO_
}

void PlayerResult::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PlayerResult)
  // required uint32 playerId = 1;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output);
  }

  // required uint32 resultCard1 = 2;
  if (has_resultcard1()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->resultcard1(), output);
  }

  // required uint32 resultCard2 = 3;
  if (has_resultcard2()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->resultcard2(), output);
  }

  // repeated uint32 bestHandPosition = 4 [packed = true];
  if (this->besthandposition_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_besthandposition_cached_byte_size_);
  }
  for (int i = 0; i < this->besthandposition_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
      this->besthandposition(i), output);
  }

  // required uint32 moneyWon = 5;
  if (has_moneywon()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->moneywon(), output);
  }

  // required uint32 playerMoney = 6;
  if (has_playermoney()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->playermoney(), output);
  }

  // optional uint32 cardsValue = 7;
  if (has_cardsvalue()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->cardsvalue(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PlayerResult)
}

int PlayerResult::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 playerId = 1;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required uint32 resultCard1 = 2;
    if (has_resultcard1()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->resultcard1());
    }

    // required uint32 resultCard2 = 3;
    if (has_resultcard2()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->resultcard2());
    }

    // required uint32 moneyWon = 5;
    if (has_moneywon()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->moneywon());
    }

    // required uint32 playerMoney = 6;
    if (has_playermoney()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playermoney());
    }

    // optional uint32 cardsValue = 7;
    if (has_cardsvalue()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->cardsvalue());
    }

  }
  // repeated uint32 bestHandPosition = 4 [packed = true];
  {
    int data_size = 0;
    for (int i = 0; i < this->besthandposition_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->besthandposition(i));
    }
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _besthandposition_cached_byte_size_ = data_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PlayerResult::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PlayerResult*>(&from));
}

void PlayerResult::MergeFrom(const PlayerResult& from) {
  GOOGLE_CHECK_NE(&from, this);
  besthandposition_.MergeFrom(from.besthandposition_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_resultcard1()) {
      set_resultcard1(from.resultcard1());
    }
    if (from.has_resultcard2()) {
      set_resultcard2(from.resultcard2());
    }
    if (from.has_moneywon()) {
      set_moneywon(from.moneywon());
    }
    if (from.has_playermoney()) {
      set_playermoney(from.playermoney());
    }
    if (from.has_cardsvalue()) {
      set_cardsvalue(from.cardsvalue());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PlayerResult::CopyFrom(const PlayerResult& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlayerResult::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000037) != 0x00000037) return false;

  return true;
}

void PlayerResult::Swap(PlayerResult* other) {
  if (other != this) {
    std::swap(playerid_, other->playerid_);
    std::swap(resultcard1_, other->resultcard1_);
    std::swap(resultcard2_, other->resultcard2_);
    besthandposition_.Swap(&other->besthandposition_);
    std::swap(moneywon_, other->moneywon_);
    std::swap(playermoney_, other->playermoney_);
    std::swap(cardsvalue_, other->cardsvalue_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PlayerResult::GetTypeName() const {
  return "PlayerResult";
}


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

bool AnnounceMessage_ServerType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const AnnounceMessage_ServerType AnnounceMessage::serverTypeLAN;
const AnnounceMessage_ServerType AnnounceMessage::serverTypeInternetNoAuth;
const AnnounceMessage_ServerType AnnounceMessage::serverTypeInternetAuth;
const AnnounceMessage_ServerType AnnounceMessage::ServerType_MIN;
const AnnounceMessage_ServerType AnnounceMessage::ServerType_MAX;
const int AnnounceMessage::ServerType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int AnnounceMessage_Version::kMajorVersionFieldNumber;
const int AnnounceMessage_Version::kMinorVersionFieldNumber;
#endif  // !_MSC_VER

AnnounceMessage_Version::AnnounceMessage_Version()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AnnounceMessage.Version)
}

void AnnounceMessage_Version::InitAsDefaultInstance() {
}

AnnounceMessage_Version::AnnounceMessage_Version(const AnnounceMessage_Version& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AnnounceMessage.Version)
}

void AnnounceMessage_Version::SharedCtor() {
  _cached_size_ = 0;
  majorversion_ = 0u;
  minorversion_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AnnounceMessage_Version::~AnnounceMessage_Version() {
  // @@protoc_insertion_point(destructor:AnnounceMessage.Version)
  SharedDtor();
}

void AnnounceMessage_Version::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AnnounceMessage_Version::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AnnounceMessage_Version& AnnounceMessage_Version::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AnnounceMessage_Version* AnnounceMessage_Version::default_instance_ = NULL;

AnnounceMessage_Version* AnnounceMessage_Version::New() const {
  return new AnnounceMessage_Version;
}

void AnnounceMessage_Version::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<AnnounceMessage_Version*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(majorversion_, minorversion_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AnnounceMessage_Version::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AnnounceMessage.Version)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 majorVersion = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &majorversion_)));
          set_has_majorversion();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_minorVersion;
        break;
      }

      // required uint32 minorVersion = 2;
      case 2: {
        if (tag == 16) {
         parse_minorVersion:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &minorversion_)));
          set_has_minorversion();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AnnounceMessage.Version)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AnnounceMessage.Version)
  return false;
#undef DO_
}

void AnnounceMessage_Version::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AnnounceMessage.Version)
  // required uint32 majorVersion = 1;
  if (has_majorversion()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->majorversion(), output);
  }

  // required uint32 minorVersion = 2;
  if (has_minorversion()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->minorversion(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AnnounceMessage.Version)
}

int AnnounceMessage_Version::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 majorVersion = 1;
    if (has_majorversion()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->majorversion());
    }

    // required uint32 minorVersion = 2;
    if (has_minorversion()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->minorversion());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AnnounceMessage_Version::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AnnounceMessage_Version*>(&from));
}

void AnnounceMessage_Version::MergeFrom(const AnnounceMessage_Version& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_majorversion()) {
      set_majorversion(from.majorversion());
    }
    if (from.has_minorversion()) {
      set_minorversion(from.minorversion());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AnnounceMessage_Version::CopyFrom(const AnnounceMessage_Version& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AnnounceMessage_Version::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void AnnounceMessage_Version::Swap(AnnounceMessage_Version* other) {
  if (other != this) {
    std::swap(majorversion_, other->majorversion_);
    std::swap(minorversion_, other->minorversion_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AnnounceMessage_Version::GetTypeName() const {
  return "AnnounceMessage.Version";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int AnnounceMessage::kProtocolVersionFieldNumber;
const int AnnounceMessage::kLatestGameVersionFieldNumber;
const int AnnounceMessage::kLatestBetaRevisionFieldNumber;
const int AnnounceMessage::kServerTypeFieldNumber;
const int AnnounceMessage::kNumPlayersOnServerFieldNumber;
#endif  // !_MSC_VER

AnnounceMessage::AnnounceMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AnnounceMessage)
}

void AnnounceMessage::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protocolversion_ = const_cast< ::AnnounceMessage_Version*>(
      ::AnnounceMessage_Version::internal_default_instance());
#else
  protocolversion_ = const_cast< ::AnnounceMessage_Version*>(&::AnnounceMessage_Version::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  latestgameversion_ = const_cast< ::AnnounceMessage_Version*>(
      ::AnnounceMessage_Version::internal_default_instance());
#else
  latestgameversion_ = const_cast< ::AnnounceMessage_Version*>(&::AnnounceMessage_Version::default_instance());
#endif
}

AnnounceMessage::AnnounceMessage(const AnnounceMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AnnounceMessage)
}

void AnnounceMessage::SharedCtor() {
  _cached_size_ = 0;
  protocolversion_ = NULL;
  latestgameversion_ = NULL;
  latestbetarevision_ = 0u;
  servertype_ = 0;
  numplayersonserver_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AnnounceMessage::~AnnounceMessage() {
  // @@protoc_insertion_point(destructor:AnnounceMessage)
  SharedDtor();
}

void AnnounceMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete protocolversion_;
    delete latestgameversion_;
  }
}

void AnnounceMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AnnounceMessage& AnnounceMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AnnounceMessage* AnnounceMessage::default_instance_ = NULL;

AnnounceMessage* AnnounceMessage::New() const {
  return new AnnounceMessage;
}

void AnnounceMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<AnnounceMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 31) {
    ZR_(latestbetarevision_, numplayersonserver_);
    if (has_protocolversion()) {
      if (protocolversion_ != NULL) protocolversion_->::AnnounceMessage_Version::Clear();
    }
    if (has_latestgameversion()) {
      if (latestgameversion_ != NULL) latestgameversion_->::AnnounceMessage_Version::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AnnounceMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AnnounceMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .AnnounceMessage.Version protocolVersion = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_protocolversion()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_latestGameVersion;
        break;
      }

      // required .AnnounceMessage.Version latestGameVersion = 2;
      case 2: {
        if (tag == 18) {
         parse_latestGameVersion:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_latestgameversion()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_latestBetaRevision;
        break;
      }

      // required uint32 latestBetaRevision = 3;
      case 3: {
        if (tag == 24) {
         parse_latestBetaRevision:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &latestbetarevision_)));
          set_has_latestbetarevision();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_serverType;
        break;
      }

      // required .AnnounceMessage.ServerType serverType = 4;
      case 4: {
        if (tag == 32) {
         parse_serverType:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::AnnounceMessage_ServerType_IsValid(value)) {
            set_servertype(static_cast< ::AnnounceMessage_ServerType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_numPlayersOnServer;
        break;
      }

      // required uint32 numPlayersOnServer = 5;
      case 5: {
        if (tag == 40) {
         parse_numPlayersOnServer:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &numplayersonserver_)));
          set_has_numplayersonserver();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AnnounceMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AnnounceMessage)
  return false;
#undef DO_
}

void AnnounceMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AnnounceMessage)
  // required .AnnounceMessage.Version protocolVersion = 1;
  if (has_protocolversion()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->protocolversion(), output);
  }

  // required .AnnounceMessage.Version latestGameVersion = 2;
  if (has_latestgameversion()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->latestgameversion(), output);
  }

  // required uint32 latestBetaRevision = 3;
  if (has_latestbetarevision()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->latestbetarevision(), output);
  }

  // required .AnnounceMessage.ServerType serverType = 4;
  if (has_servertype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->servertype(), output);
  }

  // required uint32 numPlayersOnServer = 5;
  if (has_numplayersonserver()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->numplayersonserver(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AnnounceMessage)
}

int AnnounceMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .AnnounceMessage.Version protocolVersion = 1;
    if (has_protocolversion()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->protocolversion());
    }

    // required .AnnounceMessage.Version latestGameVersion = 2;
    if (has_latestgameversion()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->latestgameversion());
    }

    // required uint32 latestBetaRevision = 3;
    if (has_latestbetarevision()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->latestbetarevision());
    }

    // required .AnnounceMessage.ServerType serverType = 4;
    if (has_servertype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->servertype());
    }

    // required uint32 numPlayersOnServer = 5;
    if (has_numplayersonserver()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->numplayersonserver());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AnnounceMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AnnounceMessage*>(&from));
}

void AnnounceMessage::MergeFrom(const AnnounceMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_protocolversion()) {
      mutable_protocolversion()->::AnnounceMessage_Version::MergeFrom(from.protocolversion());
    }
    if (from.has_latestgameversion()) {
      mutable_latestgameversion()->::AnnounceMessage_Version::MergeFrom(from.latestgameversion());
    }
    if (from.has_latestbetarevision()) {
      set_latestbetarevision(from.latestbetarevision());
    }
    if (from.has_servertype()) {
      set_servertype(from.servertype());
    }
    if (from.has_numplayersonserver()) {
      set_numplayersonserver(from.numplayersonserver());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AnnounceMessage::CopyFrom(const AnnounceMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AnnounceMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;

  if (has_protocolversion()) {
    if (!this->protocolversion().IsInitialized()) return false;
  }
  if (has_latestgameversion()) {
    if (!this->latestgameversion().IsInitialized()) return false;
  }
  return true;
}

void AnnounceMessage::Swap(AnnounceMessage* other) {
  if (other != this) {
    std::swap(protocolversion_, other->protocolversion_);
    std::swap(latestgameversion_, other->latestgameversion_);
    std::swap(latestbetarevision_, other->latestbetarevision_);
    std::swap(servertype_, other->servertype_);
    std::swap(numplayersonserver_, other->numplayersonserver_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AnnounceMessage::GetTypeName() const {
  return "AnnounceMessage";
}


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

bool InitMessage_LoginType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const InitMessage_LoginType InitMessage::guestLogin;
const InitMessage_LoginType InitMessage::authenticatedLogin;
const InitMessage_LoginType InitMessage::unauthenticatedLogin;
const InitMessage_LoginType InitMessage::LoginType_MIN;
const InitMessage_LoginType InitMessage::LoginType_MAX;
const int InitMessage::LoginType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int InitMessage::kRequestedVersionFieldNumber;
const int InitMessage::kBuildIdFieldNumber;
const int InitMessage::kMyLastSessionIdFieldNumber;
const int InitMessage::kAuthServerPasswordFieldNumber;
const int InitMessage::kLoginFieldNumber;
const int InitMessage::kNickNameFieldNumber;
const int InitMessage::kClientUserDataFieldNumber;
const int InitMessage::kAvatarHashFieldNumber;
#endif  // !_MSC_VER

InitMessage::InitMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:InitMessage)
}

void InitMessage::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  requestedversion_ = const_cast< ::AnnounceMessage_Version*>(
      ::AnnounceMessage_Version::internal_default_instance());
#else
  requestedversion_ = const_cast< ::AnnounceMessage_Version*>(&::AnnounceMessage_Version::default_instance());
#endif
}

InitMessage::InitMessage(const InitMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:InitMessage)
}

void InitMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  requestedversion_ = NULL;
  buildid_ = 0u;
  mylastsessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  authserverpassword_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  login_ = 0;
  nickname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clientuserdata_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

InitMessage::~InitMessage() {
  // @@protoc_insertion_point(destructor:InitMessage)
  SharedDtor();
}

void InitMessage::SharedDtor() {
  if (mylastsessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete mylastsessionid_;
  }
  if (authserverpassword_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete authserverpassword_;
  }
  if (nickname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete nickname_;
  }
  if (clientuserdata_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete clientuserdata_;
  }
  if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete avatarhash_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete requestedversion_;
  }
}

void InitMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const InitMessage& InitMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

InitMessage* InitMessage::default_instance_ = NULL;

InitMessage* InitMessage::New() const {
  return new InitMessage;
}

void InitMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<InitMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 255) {
    ZR_(buildid_, login_);
    if (has_requestedversion()) {
      if (requestedversion_ != NULL) requestedversion_->::AnnounceMessage_Version::Clear();
    }
    if (has_mylastsessionid()) {
      if (mylastsessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        mylastsessionid_->clear();
      }
    }
    if (has_authserverpassword()) {
      if (authserverpassword_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        authserverpassword_->clear();
      }
    }
    if (has_nickname()) {
      if (nickname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        nickname_->clear();
      }
    }
    if (has_clientuserdata()) {
      if (clientuserdata_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        clientuserdata_->clear();
      }
    }
    if (has_avatarhash()) {
      if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        avatarhash_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool InitMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:InitMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .AnnounceMessage.Version requestedVersion = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_requestedversion()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_buildId;
        break;
      }

      // required uint32 buildId = 2;
      case 2: {
        if (tag == 16) {
         parse_buildId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &buildid_)));
          set_has_buildid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_myLastSessionId;
        break;
      }

      // optional bytes myLastSessionId = 3;
      case 3: {
        if (tag == 26) {
         parse_myLastSessionId:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_mylastsessionid()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_authServerPassword;
        break;
      }

      // optional string authServerPassword = 4;
      case 4: {
        if (tag == 34) {
         parse_authServerPassword:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_authserverpassword()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_login;
        break;
      }

      // required .InitMessage.LoginType login = 5;
      case 5: {
        if (tag == 40) {
         parse_login:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::InitMessage_LoginType_IsValid(value)) {
            set_login(static_cast< ::InitMessage_LoginType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_nickName;
        break;
      }

      // optional string nickName = 6;
      case 6: {
        if (tag == 50) {
         parse_nickName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_nickname()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_clientUserData;
        break;
      }

      // optional bytes clientUserData = 7;
      case 7: {
        if (tag == 58) {
         parse_clientUserData:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_clientuserdata()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(66)) goto parse_avatarHash;
        break;
      }

      // optional bytes avatarHash = 8;
      case 8: {
        if (tag == 66) {
         parse_avatarHash:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_avatarhash()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:InitMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:InitMessage)
  return false;
#undef DO_
}

void InitMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:InitMessage)
  // required .AnnounceMessage.Version requestedVersion = 1;
  if (has_requestedversion()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->requestedversion(), output);
  }

  // required uint32 buildId = 2;
  if (has_buildid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->buildid(), output);
  }

  // optional bytes myLastSessionId = 3;
  if (has_mylastsessionid()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->mylastsessionid(), output);
  }

  // optional string authServerPassword = 4;
  if (has_authserverpassword()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->authserverpassword(), output);
  }

  // required .InitMessage.LoginType login = 5;
  if (has_login()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->login(), output);
  }

  // optional string nickName = 6;
  if (has_nickname()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      6, this->nickname(), output);
  }

  // optional bytes clientUserData = 7;
  if (has_clientuserdata()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      7, this->clientuserdata(), output);
  }

  // optional bytes avatarHash = 8;
  if (has_avatarhash()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      8, this->avatarhash(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:InitMessage)
}

int InitMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .AnnounceMessage.Version requestedVersion = 1;
    if (has_requestedversion()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->requestedversion());
    }

    // required uint32 buildId = 2;
    if (has_buildid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->buildid());
    }

    // optional bytes myLastSessionId = 3;
    if (has_mylastsessionid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->mylastsessionid());
    }

    // optional string authServerPassword = 4;
    if (has_authserverpassword()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->authserverpassword());
    }

    // required .InitMessage.LoginType login = 5;
    if (has_login()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->login());
    }

    // optional string nickName = 6;
    if (has_nickname()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->nickname());
    }

    // optional bytes clientUserData = 7;
    if (has_clientuserdata()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->clientuserdata());
    }

    // optional bytes avatarHash = 8;
    if (has_avatarhash()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->avatarhash());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void InitMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const InitMessage*>(&from));
}

void InitMessage::MergeFrom(const InitMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_requestedversion()) {
      mutable_requestedversion()->::AnnounceMessage_Version::MergeFrom(from.requestedversion());
    }
    if (from.has_buildid()) {
      set_buildid(from.buildid());
    }
    if (from.has_mylastsessionid()) {
      set_mylastsessionid(from.mylastsessionid());
    }
    if (from.has_authserverpassword()) {
      set_authserverpassword(from.authserverpassword());
    }
    if (from.has_login()) {
      set_login(from.login());
    }
    if (from.has_nickname()) {
      set_nickname(from.nickname());
    }
    if (from.has_clientuserdata()) {
      set_clientuserdata(from.clientuserdata());
    }
    if (from.has_avatarhash()) {
      set_avatarhash(from.avatarhash());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void InitMessage::CopyFrom(const InitMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool InitMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000013) != 0x00000013) return false;

  if (has_requestedversion()) {
    if (!this->requestedversion().IsInitialized()) return false;
  }
  return true;
}

void InitMessage::Swap(InitMessage* other) {
  if (other != this) {
    std::swap(requestedversion_, other->requestedversion_);
    std::swap(buildid_, other->buildid_);
    std::swap(mylastsessionid_, other->mylastsessionid_);
    std::swap(authserverpassword_, other->authserverpassword_);
    std::swap(login_, other->login_);
    std::swap(nickname_, other->nickname_);
    std::swap(clientuserdata_, other->clientuserdata_);
    std::swap(avatarhash_, other->avatarhash_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string InitMessage::GetTypeName() const {
  return "InitMessage";
}


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

#ifndef _MSC_VER
const int AuthServerChallengeMessage::kServerChallengeFieldNumber;
#endif  // !_MSC_VER

AuthServerChallengeMessage::AuthServerChallengeMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AuthServerChallengeMessage)
}

void AuthServerChallengeMessage::InitAsDefaultInstance() {
}

AuthServerChallengeMessage::AuthServerChallengeMessage(const AuthServerChallengeMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AuthServerChallengeMessage)
}

void AuthServerChallengeMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  serverchallenge_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AuthServerChallengeMessage::~AuthServerChallengeMessage() {
  // @@protoc_insertion_point(destructor:AuthServerChallengeMessage)
  SharedDtor();
}

void AuthServerChallengeMessage::SharedDtor() {
  if (serverchallenge_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete serverchallenge_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AuthServerChallengeMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AuthServerChallengeMessage& AuthServerChallengeMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AuthServerChallengeMessage* AuthServerChallengeMessage::default_instance_ = NULL;

AuthServerChallengeMessage* AuthServerChallengeMessage::New() const {
  return new AuthServerChallengeMessage;
}

void AuthServerChallengeMessage::Clear() {
  if (has_serverchallenge()) {
    if (serverchallenge_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      serverchallenge_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AuthServerChallengeMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AuthServerChallengeMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes serverChallenge = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_serverchallenge()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AuthServerChallengeMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AuthServerChallengeMessage)
  return false;
#undef DO_
}

void AuthServerChallengeMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AuthServerChallengeMessage)
  // required bytes serverChallenge = 1;
  if (has_serverchallenge()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->serverchallenge(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AuthServerChallengeMessage)
}

int AuthServerChallengeMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required bytes serverChallenge = 1;
    if (has_serverchallenge()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->serverchallenge());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AuthServerChallengeMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AuthServerChallengeMessage*>(&from));
}

void AuthServerChallengeMessage::MergeFrom(const AuthServerChallengeMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_serverchallenge()) {
      set_serverchallenge(from.serverchallenge());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AuthServerChallengeMessage::CopyFrom(const AuthServerChallengeMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AuthServerChallengeMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void AuthServerChallengeMessage::Swap(AuthServerChallengeMessage* other) {
  if (other != this) {
    std::swap(serverchallenge_, other->serverchallenge_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AuthServerChallengeMessage::GetTypeName() const {
  return "AuthServerChallengeMessage";
}


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

#ifndef _MSC_VER
const int AuthClientResponseMessage::kClientResponseFieldNumber;
#endif  // !_MSC_VER

AuthClientResponseMessage::AuthClientResponseMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AuthClientResponseMessage)
}

void AuthClientResponseMessage::InitAsDefaultInstance() {
}

AuthClientResponseMessage::AuthClientResponseMessage(const AuthClientResponseMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AuthClientResponseMessage)
}

void AuthClientResponseMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  clientresponse_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AuthClientResponseMessage::~AuthClientResponseMessage() {
  // @@protoc_insertion_point(destructor:AuthClientResponseMessage)
  SharedDtor();
}

void AuthClientResponseMessage::SharedDtor() {
  if (clientresponse_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete clientresponse_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AuthClientResponseMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AuthClientResponseMessage& AuthClientResponseMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AuthClientResponseMessage* AuthClientResponseMessage::default_instance_ = NULL;

AuthClientResponseMessage* AuthClientResponseMessage::New() const {
  return new AuthClientResponseMessage;
}

void AuthClientResponseMessage::Clear() {
  if (has_clientresponse()) {
    if (clientresponse_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      clientresponse_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AuthClientResponseMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AuthClientResponseMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes clientResponse = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_clientresponse()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AuthClientResponseMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AuthClientResponseMessage)
  return false;
#undef DO_
}

void AuthClientResponseMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AuthClientResponseMessage)
  // required bytes clientResponse = 1;
  if (has_clientresponse()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->clientresponse(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AuthClientResponseMessage)
}

int AuthClientResponseMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required bytes clientResponse = 1;
    if (has_clientresponse()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->clientresponse());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AuthClientResponseMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AuthClientResponseMessage*>(&from));
}

void AuthClientResponseMessage::MergeFrom(const AuthClientResponseMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_clientresponse()) {
      set_clientresponse(from.clientresponse());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AuthClientResponseMessage::CopyFrom(const AuthClientResponseMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AuthClientResponseMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void AuthClientResponseMessage::Swap(AuthClientResponseMessage* other) {
  if (other != this) {
    std::swap(clientresponse_, other->clientresponse_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AuthClientResponseMessage::GetTypeName() const {
  return "AuthClientResponseMessage";
}


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

#ifndef _MSC_VER
const int AuthServerVerificationMessage::kServerVerificationFieldNumber;
#endif  // !_MSC_VER

AuthServerVerificationMessage::AuthServerVerificationMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AuthServerVerificationMessage)
}

void AuthServerVerificationMessage::InitAsDefaultInstance() {
}

AuthServerVerificationMessage::AuthServerVerificationMessage(const AuthServerVerificationMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AuthServerVerificationMessage)
}

void AuthServerVerificationMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  serververification_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AuthServerVerificationMessage::~AuthServerVerificationMessage() {
  // @@protoc_insertion_point(destructor:AuthServerVerificationMessage)
  SharedDtor();
}

void AuthServerVerificationMessage::SharedDtor() {
  if (serververification_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete serververification_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AuthServerVerificationMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AuthServerVerificationMessage& AuthServerVerificationMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AuthServerVerificationMessage* AuthServerVerificationMessage::default_instance_ = NULL;

AuthServerVerificationMessage* AuthServerVerificationMessage::New() const {
  return new AuthServerVerificationMessage;
}

void AuthServerVerificationMessage::Clear() {
  if (has_serververification()) {
    if (serververification_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      serververification_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AuthServerVerificationMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AuthServerVerificationMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes serverVerification = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_serververification()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AuthServerVerificationMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AuthServerVerificationMessage)
  return false;
#undef DO_
}

void AuthServerVerificationMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AuthServerVerificationMessage)
  // required bytes serverVerification = 1;
  if (has_serververification()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->serververification(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AuthServerVerificationMessage)
}

int AuthServerVerificationMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required bytes serverVerification = 1;
    if (has_serververification()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->serververification());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AuthServerVerificationMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AuthServerVerificationMessage*>(&from));
}

void AuthServerVerificationMessage::MergeFrom(const AuthServerVerificationMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_serververification()) {
      set_serververification(from.serververification());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AuthServerVerificationMessage::CopyFrom(const AuthServerVerificationMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AuthServerVerificationMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void AuthServerVerificationMessage::Swap(AuthServerVerificationMessage* other) {
  if (other != this) {
    std::swap(serververification_, other->serververification_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AuthServerVerificationMessage::GetTypeName() const {
  return "AuthServerVerificationMessage";
}


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

#ifndef _MSC_VER
const int InitAckMessage::kYourSessionIdFieldNumber;
const int InitAckMessage::kYourPlayerIdFieldNumber;
const int InitAckMessage::kYourAvatarHashFieldNumber;
const int InitAckMessage::kRejoinGameIdFieldNumber;
#endif  // !_MSC_VER

InitAckMessage::InitAckMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:InitAckMessage)
}

void InitAckMessage::InitAsDefaultInstance() {
}

InitAckMessage::InitAckMessage(const InitAckMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:InitAckMessage)
}

void InitAckMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  yoursessionid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  yourplayerid_ = 0u;
  youravatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  rejoingameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

InitAckMessage::~InitAckMessage() {
  // @@protoc_insertion_point(destructor:InitAckMessage)
  SharedDtor();
}

void InitAckMessage::SharedDtor() {
  if (yoursessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete yoursessionid_;
  }
  if (youravatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete youravatarhash_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void InitAckMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const InitAckMessage& InitAckMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

InitAckMessage* InitAckMessage::default_instance_ = NULL;

InitAckMessage* InitAckMessage::New() const {
  return new InitAckMessage;
}

void InitAckMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<InitAckMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(yourplayerid_, rejoingameid_);
    if (has_yoursessionid()) {
      if (yoursessionid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        yoursessionid_->clear();
      }
    }
    if (has_youravatarhash()) {
      if (youravatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        youravatarhash_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool InitAckMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:InitAckMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes yourSessionId = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_yoursessionid()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_yourPlayerId;
        break;
      }

      // required uint32 yourPlayerId = 2;
      case 2: {
        if (tag == 16) {
         parse_yourPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &yourplayerid_)));
          set_has_yourplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_yourAvatarHash;
        break;
      }

      // optional bytes yourAvatarHash = 3;
      case 3: {
        if (tag == 26) {
         parse_yourAvatarHash:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_youravatarhash()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_rejoinGameId;
        break;
      }

      // optional uint32 rejoinGameId = 4;
      case 4: {
        if (tag == 32) {
         parse_rejoinGameId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &rejoingameid_)));
          set_has_rejoingameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:InitAckMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:InitAckMessage)
  return false;
#undef DO_
}

void InitAckMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:InitAckMessage)
  // required bytes yourSessionId = 1;
  if (has_yoursessionid()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->yoursessionid(), output);
  }

  // required uint32 yourPlayerId = 2;
  if (has_yourplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->yourplayerid(), output);
  }

  // optional bytes yourAvatarHash = 3;
  if (has_youravatarhash()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->youravatarhash(), output);
  }

  // optional uint32 rejoinGameId = 4;
  if (has_rejoingameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->rejoingameid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:InitAckMessage)
}

int InitAckMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required bytes yourSessionId = 1;
    if (has_yoursessionid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->yoursessionid());
    }

    // required uint32 yourPlayerId = 2;
    if (has_yourplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->yourplayerid());
    }

    // optional bytes yourAvatarHash = 3;
    if (has_youravatarhash()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->youravatarhash());
    }

    // optional uint32 rejoinGameId = 4;
    if (has_rejoingameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->rejoingameid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void InitAckMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const InitAckMessage*>(&from));
}

void InitAckMessage::MergeFrom(const InitAckMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_yoursessionid()) {
      set_yoursessionid(from.yoursessionid());
    }
    if (from.has_yourplayerid()) {
      set_yourplayerid(from.yourplayerid());
    }
    if (from.has_youravatarhash()) {
      set_youravatarhash(from.youravatarhash());
    }
    if (from.has_rejoingameid()) {
      set_rejoingameid(from.rejoingameid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void InitAckMessage::CopyFrom(const InitAckMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool InitAckMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void InitAckMessage::Swap(InitAckMessage* other) {
  if (other != this) {
    std::swap(yoursessionid_, other->yoursessionid_);
    std::swap(yourplayerid_, other->yourplayerid_);
    std::swap(youravatarhash_, other->youravatarhash_);
    std::swap(rejoingameid_, other->rejoingameid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string InitAckMessage::GetTypeName() const {
  return "InitAckMessage";
}


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

#ifndef _MSC_VER
const int AvatarRequestMessage::kRequestIdFieldNumber;
const int AvatarRequestMessage::kAvatarHashFieldNumber;
#endif  // !_MSC_VER

AvatarRequestMessage::AvatarRequestMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AvatarRequestMessage)
}

void AvatarRequestMessage::InitAsDefaultInstance() {
}

AvatarRequestMessage::AvatarRequestMessage(const AvatarRequestMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AvatarRequestMessage)
}

void AvatarRequestMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  requestid_ = 0u;
  avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AvatarRequestMessage::~AvatarRequestMessage() {
  // @@protoc_insertion_point(destructor:AvatarRequestMessage)
  SharedDtor();
}

void AvatarRequestMessage::SharedDtor() {
  if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete avatarhash_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AvatarRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AvatarRequestMessage& AvatarRequestMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AvatarRequestMessage* AvatarRequestMessage::default_instance_ = NULL;

AvatarRequestMessage* AvatarRequestMessage::New() const {
  return new AvatarRequestMessage;
}

void AvatarRequestMessage::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    requestid_ = 0u;
    if (has_avatarhash()) {
      if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        avatarhash_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AvatarRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AvatarRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 requestId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &requestid_)));
          set_has_requestid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_avatarHash;
        break;
      }

      // required bytes avatarHash = 2;
      case 2: {
        if (tag == 18) {
         parse_avatarHash:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_avatarhash()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AvatarRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AvatarRequestMessage)
  return false;
#undef DO_
}

void AvatarRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AvatarRequestMessage)
  // required uint32 requestId = 1;
  if (has_requestid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
  }

  // required bytes avatarHash = 2;
  if (has_avatarhash()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->avatarhash(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AvatarRequestMessage)
}

int AvatarRequestMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 requestId = 1;
    if (has_requestid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->requestid());
    }

    // required bytes avatarHash = 2;
    if (has_avatarhash()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->avatarhash());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AvatarRequestMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AvatarRequestMessage*>(&from));
}

void AvatarRequestMessage::MergeFrom(const AvatarRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_requestid()) {
      set_requestid(from.requestid());
    }
    if (from.has_avatarhash()) {
      set_avatarhash(from.avatarhash());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AvatarRequestMessage::CopyFrom(const AvatarRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AvatarRequestMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void AvatarRequestMessage::Swap(AvatarRequestMessage* other) {
  if (other != this) {
    std::swap(requestid_, other->requestid_);
    std::swap(avatarhash_, other->avatarhash_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AvatarRequestMessage::GetTypeName() const {
  return "AvatarRequestMessage";
}


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

#ifndef _MSC_VER
const int AvatarHeaderMessage::kRequestIdFieldNumber;
const int AvatarHeaderMessage::kAvatarTypeFieldNumber;
const int AvatarHeaderMessage::kAvatarSizeFieldNumber;
#endif  // !_MSC_VER

AvatarHeaderMessage::AvatarHeaderMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AvatarHeaderMessage)
}

void AvatarHeaderMessage::InitAsDefaultInstance() {
}

AvatarHeaderMessage::AvatarHeaderMessage(const AvatarHeaderMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AvatarHeaderMessage)
}

void AvatarHeaderMessage::SharedCtor() {
  _cached_size_ = 0;
  requestid_ = 0u;
  avatartype_ = 1;
  avatarsize_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AvatarHeaderMessage::~AvatarHeaderMessage() {
  // @@protoc_insertion_point(destructor:AvatarHeaderMessage)
  SharedDtor();
}

void AvatarHeaderMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AvatarHeaderMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AvatarHeaderMessage& AvatarHeaderMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AvatarHeaderMessage* AvatarHeaderMessage::default_instance_ = NULL;

AvatarHeaderMessage* AvatarHeaderMessage::New() const {
  return new AvatarHeaderMessage;
}

void AvatarHeaderMessage::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    requestid_ = 0u;
    avatartype_ = 1;
    avatarsize_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AvatarHeaderMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AvatarHeaderMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 requestId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &requestid_)));
          set_has_requestid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_avatarType;
        break;
      }

      // required .NetAvatarType avatarType = 2;
      case 2: {
        if (tag == 16) {
         parse_avatarType:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetAvatarType_IsValid(value)) {
            set_avatartype(static_cast< ::NetAvatarType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_avatarSize;
        break;
      }

      // required uint32 avatarSize = 3;
      case 3: {
        if (tag == 24) {
         parse_avatarSize:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &avatarsize_)));
          set_has_avatarsize();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AvatarHeaderMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AvatarHeaderMessage)
  return false;
#undef DO_
}

void AvatarHeaderMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AvatarHeaderMessage)
  // required uint32 requestId = 1;
  if (has_requestid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
  }

  // required .NetAvatarType avatarType = 2;
  if (has_avatartype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->avatartype(), output);
  }

  // required uint32 avatarSize = 3;
  if (has_avatarsize()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->avatarsize(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AvatarHeaderMessage)
}

int AvatarHeaderMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 requestId = 1;
    if (has_requestid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->requestid());
    }

    // required .NetAvatarType avatarType = 2;
    if (has_avatartype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->avatartype());
    }

    // required uint32 avatarSize = 3;
    if (has_avatarsize()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->avatarsize());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AvatarHeaderMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AvatarHeaderMessage*>(&from));
}

void AvatarHeaderMessage::MergeFrom(const AvatarHeaderMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_requestid()) {
      set_requestid(from.requestid());
    }
    if (from.has_avatartype()) {
      set_avatartype(from.avatartype());
    }
    if (from.has_avatarsize()) {
      set_avatarsize(from.avatarsize());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AvatarHeaderMessage::CopyFrom(const AvatarHeaderMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AvatarHeaderMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void AvatarHeaderMessage::Swap(AvatarHeaderMessage* other) {
  if (other != this) {
    std::swap(requestid_, other->requestid_);
    std::swap(avatartype_, other->avatartype_);
    std::swap(avatarsize_, other->avatarsize_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AvatarHeaderMessage::GetTypeName() const {
  return "AvatarHeaderMessage";
}


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

#ifndef _MSC_VER
const int AvatarDataMessage::kRequestIdFieldNumber;
const int AvatarDataMessage::kAvatarBlockFieldNumber;
#endif  // !_MSC_VER

AvatarDataMessage::AvatarDataMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AvatarDataMessage)
}

void AvatarDataMessage::InitAsDefaultInstance() {
}

AvatarDataMessage::AvatarDataMessage(const AvatarDataMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AvatarDataMessage)
}

void AvatarDataMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  requestid_ = 0u;
  avatarblock_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AvatarDataMessage::~AvatarDataMessage() {
  // @@protoc_insertion_point(destructor:AvatarDataMessage)
  SharedDtor();
}

void AvatarDataMessage::SharedDtor() {
  if (avatarblock_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete avatarblock_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AvatarDataMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AvatarDataMessage& AvatarDataMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AvatarDataMessage* AvatarDataMessage::default_instance_ = NULL;

AvatarDataMessage* AvatarDataMessage::New() const {
  return new AvatarDataMessage;
}

void AvatarDataMessage::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    requestid_ = 0u;
    if (has_avatarblock()) {
      if (avatarblock_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        avatarblock_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AvatarDataMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AvatarDataMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 requestId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &requestid_)));
          set_has_requestid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_avatarBlock;
        break;
      }

      // required bytes avatarBlock = 2;
      case 2: {
        if (tag == 18) {
         parse_avatarBlock:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_avatarblock()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AvatarDataMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AvatarDataMessage)
  return false;
#undef DO_
}

void AvatarDataMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AvatarDataMessage)
  // required uint32 requestId = 1;
  if (has_requestid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
  }

  // required bytes avatarBlock = 2;
  if (has_avatarblock()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->avatarblock(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AvatarDataMessage)
}

int AvatarDataMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 requestId = 1;
    if (has_requestid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->requestid());
    }

    // required bytes avatarBlock = 2;
    if (has_avatarblock()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->avatarblock());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AvatarDataMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AvatarDataMessage*>(&from));
}

void AvatarDataMessage::MergeFrom(const AvatarDataMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_requestid()) {
      set_requestid(from.requestid());
    }
    if (from.has_avatarblock()) {
      set_avatarblock(from.avatarblock());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AvatarDataMessage::CopyFrom(const AvatarDataMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AvatarDataMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void AvatarDataMessage::Swap(AvatarDataMessage* other) {
  if (other != this) {
    std::swap(requestid_, other->requestid_);
    std::swap(avatarblock_, other->avatarblock_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AvatarDataMessage::GetTypeName() const {
  return "AvatarDataMessage";
}


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

#ifndef _MSC_VER
const int AvatarEndMessage::kRequestIdFieldNumber;
#endif  // !_MSC_VER

AvatarEndMessage::AvatarEndMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AvatarEndMessage)
}

void AvatarEndMessage::InitAsDefaultInstance() {
}

AvatarEndMessage::AvatarEndMessage(const AvatarEndMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AvatarEndMessage)
}

void AvatarEndMessage::SharedCtor() {
  _cached_size_ = 0;
  requestid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AvatarEndMessage::~AvatarEndMessage() {
  // @@protoc_insertion_point(destructor:AvatarEndMessage)
  SharedDtor();
}

void AvatarEndMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AvatarEndMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AvatarEndMessage& AvatarEndMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AvatarEndMessage* AvatarEndMessage::default_instance_ = NULL;

AvatarEndMessage* AvatarEndMessage::New() const {
  return new AvatarEndMessage;
}

void AvatarEndMessage::Clear() {
  requestid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AvatarEndMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AvatarEndMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 requestId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &requestid_)));
          set_has_requestid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AvatarEndMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AvatarEndMessage)
  return false;
#undef DO_
}

void AvatarEndMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AvatarEndMessage)
  // required uint32 requestId = 1;
  if (has_requestid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AvatarEndMessage)
}

int AvatarEndMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 requestId = 1;
    if (has_requestid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->requestid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AvatarEndMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AvatarEndMessage*>(&from));
}

void AvatarEndMessage::MergeFrom(const AvatarEndMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_requestid()) {
      set_requestid(from.requestid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AvatarEndMessage::CopyFrom(const AvatarEndMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AvatarEndMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void AvatarEndMessage::Swap(AvatarEndMessage* other) {
  if (other != this) {
    std::swap(requestid_, other->requestid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AvatarEndMessage::GetTypeName() const {
  return "AvatarEndMessage";
}


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

#ifndef _MSC_VER
const int UnknownAvatarMessage::kRequestIdFieldNumber;
#endif  // !_MSC_VER

UnknownAvatarMessage::UnknownAvatarMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:UnknownAvatarMessage)
}

void UnknownAvatarMessage::InitAsDefaultInstance() {
}

UnknownAvatarMessage::UnknownAvatarMessage(const UnknownAvatarMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:UnknownAvatarMessage)
}

void UnknownAvatarMessage::SharedCtor() {
  _cached_size_ = 0;
  requestid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UnknownAvatarMessage::~UnknownAvatarMessage() {
  // @@protoc_insertion_point(destructor:UnknownAvatarMessage)
  SharedDtor();
}

void UnknownAvatarMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void UnknownAvatarMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const UnknownAvatarMessage& UnknownAvatarMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

UnknownAvatarMessage* UnknownAvatarMessage::default_instance_ = NULL;

UnknownAvatarMessage* UnknownAvatarMessage::New() const {
  return new UnknownAvatarMessage;
}

void UnknownAvatarMessage::Clear() {
  requestid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool UnknownAvatarMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:UnknownAvatarMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 requestId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &requestid_)));
          set_has_requestid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:UnknownAvatarMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:UnknownAvatarMessage)
  return false;
#undef DO_
}

void UnknownAvatarMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:UnknownAvatarMessage)
  // required uint32 requestId = 1;
  if (has_requestid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:UnknownAvatarMessage)
}

int UnknownAvatarMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 requestId = 1;
    if (has_requestid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->requestid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UnknownAvatarMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const UnknownAvatarMessage*>(&from));
}

void UnknownAvatarMessage::MergeFrom(const UnknownAvatarMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_requestid()) {
      set_requestid(from.requestid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void UnknownAvatarMessage::CopyFrom(const UnknownAvatarMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UnknownAvatarMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void UnknownAvatarMessage::Swap(UnknownAvatarMessage* other) {
  if (other != this) {
    std::swap(requestid_, other->requestid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string UnknownAvatarMessage::GetTypeName() const {
  return "UnknownAvatarMessage";
}


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

bool PlayerListMessage_PlayerListNotification_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const PlayerListMessage_PlayerListNotification PlayerListMessage::playerListNew;
const PlayerListMessage_PlayerListNotification PlayerListMessage::playerListLeft;
const PlayerListMessage_PlayerListNotification PlayerListMessage::PlayerListNotification_MIN;
const PlayerListMessage_PlayerListNotification PlayerListMessage::PlayerListNotification_MAX;
const int PlayerListMessage::PlayerListNotification_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int PlayerListMessage::kPlayerIdFieldNumber;
const int PlayerListMessage::kPlayerListNotificationFieldNumber;
#endif  // !_MSC_VER

PlayerListMessage::PlayerListMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PlayerListMessage)
}

void PlayerListMessage::InitAsDefaultInstance() {
}

PlayerListMessage::PlayerListMessage(const PlayerListMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PlayerListMessage)
}

void PlayerListMessage::SharedCtor() {
  _cached_size_ = 0;
  playerid_ = 0u;
  playerlistnotification_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PlayerListMessage::~PlayerListMessage() {
  // @@protoc_insertion_point(destructor:PlayerListMessage)
  SharedDtor();
}

void PlayerListMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void PlayerListMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PlayerListMessage& PlayerListMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

PlayerListMessage* PlayerListMessage::default_instance_ = NULL;

PlayerListMessage* PlayerListMessage::New() const {
  return new PlayerListMessage;
}

void PlayerListMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<PlayerListMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(playerid_, playerlistnotification_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PlayerListMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PlayerListMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 playerId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerListNotification;
        break;
      }

      // required .PlayerListMessage.PlayerListNotification playerListNotification = 2;
      case 2: {
        if (tag == 16) {
         parse_playerListNotification:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::PlayerListMessage_PlayerListNotification_IsValid(value)) {
            set_playerlistnotification(static_cast< ::PlayerListMessage_PlayerListNotification >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PlayerListMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PlayerListMessage)
  return false;
#undef DO_
}

void PlayerListMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PlayerListMessage)
  // required uint32 playerId = 1;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output);
  }

  // required .PlayerListMessage.PlayerListNotification playerListNotification = 2;
  if (has_playerlistnotification()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->playerlistnotification(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PlayerListMessage)
}

int PlayerListMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 playerId = 1;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required .PlayerListMessage.PlayerListNotification playerListNotification = 2;
    if (has_playerlistnotification()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->playerlistnotification());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PlayerListMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PlayerListMessage*>(&from));
}

void PlayerListMessage::MergeFrom(const PlayerListMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_playerlistnotification()) {
      set_playerlistnotification(from.playerlistnotification());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PlayerListMessage::CopyFrom(const PlayerListMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlayerListMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void PlayerListMessage::Swap(PlayerListMessage* other) {
  if (other != this) {
    std::swap(playerid_, other->playerid_);
    std::swap(playerlistnotification_, other->playerlistnotification_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PlayerListMessage::GetTypeName() const {
  return "PlayerListMessage";
}


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

#ifndef _MSC_VER
const int GameListNewMessage::kGameIdFieldNumber;
const int GameListNewMessage::kGameModeFieldNumber;
const int GameListNewMessage::kIsPrivateFieldNumber;
const int GameListNewMessage::kPlayerIdsFieldNumber;
const int GameListNewMessage::kAdminPlayerIdFieldNumber;
const int GameListNewMessage::kGameInfoFieldNumber;
const int GameListNewMessage::kSpectatorIdsFieldNumber;
#endif  // !_MSC_VER

GameListNewMessage::GameListNewMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameListNewMessage)
}

void GameListNewMessage::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gameinfo_ = const_cast< ::NetGameInfo*>(
      ::NetGameInfo::internal_default_instance());
#else
  gameinfo_ = const_cast< ::NetGameInfo*>(&::NetGameInfo::default_instance());
#endif
}

GameListNewMessage::GameListNewMessage(const GameListNewMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameListNewMessage)
}

void GameListNewMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  gamemode_ = 1;
  isprivate_ = false;
  adminplayerid_ = 0u;
  gameinfo_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameListNewMessage::~GameListNewMessage() {
  // @@protoc_insertion_point(destructor:GameListNewMessage)
  SharedDtor();
}

void GameListNewMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete gameinfo_;
  }
}

void GameListNewMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameListNewMessage& GameListNewMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameListNewMessage* GameListNewMessage::default_instance_ = NULL;

GameListNewMessage* GameListNewMessage::New() const {
  return new GameListNewMessage;
}

void GameListNewMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameListNewMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 55) {
    ZR_(isprivate_, adminplayerid_);
    gameid_ = 0u;
    gamemode_ = 1;
    if (has_gameinfo()) {
      if (gameinfo_ != NULL) gameinfo_->::NetGameInfo::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  playerids_.Clear();
  spectatorids_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameListNewMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameListNewMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_gameMode;
        break;
      }

      // required .NetGameMode gameMode = 2;
      case 2: {
        if (tag == 16) {
         parse_gameMode:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetGameMode_IsValid(value)) {
            set_gamemode(static_cast< ::NetGameMode >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_isPrivate;
        break;
      }

      // required bool isPrivate = 3;
      case 3: {
        if (tag == 24) {
         parse_isPrivate:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &isprivate_)));
          set_has_isprivate();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_playerIds;
        break;
      }

      // repeated uint32 playerIds = 4 [packed = true];
      case 4: {
        if (tag == 34) {
         parse_playerIds:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_playerids())));
        } else if (tag == 32) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 34, input, this->mutable_playerids())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_adminPlayerId;
        break;
      }

      // required uint32 adminPlayerId = 5;
      case 5: {
        if (tag == 40) {
         parse_adminPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &adminplayerid_)));
          set_has_adminplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_gameInfo;
        break;
      }

      // required .NetGameInfo gameInfo = 6;
      case 6: {
        if (tag == 50) {
         parse_gameInfo:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gameinfo()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_spectatorIds;
        break;
      }

      // repeated uint32 spectatorIds = 7 [packed = true];
      case 7: {
        if (tag == 58) {
         parse_spectatorIds:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_spectatorids())));
        } else if (tag == 56) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 58, input, this->mutable_spectatorids())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameListNewMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameListNewMessage)
  return false;
#undef DO_
}

void GameListNewMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameListNewMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required .NetGameMode gameMode = 2;
  if (has_gamemode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->gamemode(), output);
  }

  // required bool isPrivate = 3;
  if (has_isprivate()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->isprivate(), output);
  }

  // repeated uint32 playerIds = 4 [packed = true];
  if (this->playerids_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_playerids_cached_byte_size_);
  }
  for (int i = 0; i < this->playerids_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
      this->playerids(i), output);
  }

  // required uint32 adminPlayerId = 5;
  if (has_adminplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->adminplayerid(), output);
  }

  // required .NetGameInfo gameInfo = 6;
  if (has_gameinfo()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      6, this->gameinfo(), output);
  }

  // repeated uint32 spectatorIds = 7 [packed = true];
  if (this->spectatorids_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_spectatorids_cached_byte_size_);
  }
  for (int i = 0; i < this->spectatorids_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
      this->spectatorids(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameListNewMessage)
}

int GameListNewMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required .NetGameMode gameMode = 2;
    if (has_gamemode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->gamemode());
    }

    // required bool isPrivate = 3;
    if (has_isprivate()) {
      total_size += 1 + 1;
    }

    // required uint32 adminPlayerId = 5;
    if (has_adminplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->adminplayerid());
    }

    // required .NetGameInfo gameInfo = 6;
    if (has_gameinfo()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gameinfo());
    }

  }
  // repeated uint32 playerIds = 4 [packed = true];
  {
    int data_size = 0;
    for (int i = 0; i < this->playerids_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->playerids(i));
    }
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _playerids_cached_byte_size_ = data_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  // repeated uint32 spectatorIds = 7 [packed = true];
  {
    int data_size = 0;
    for (int i = 0; i < this->spectatorids_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->spectatorids(i));
    }
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _spectatorids_cached_byte_size_ = data_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameListNewMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameListNewMessage*>(&from));
}

void GameListNewMessage::MergeFrom(const GameListNewMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  playerids_.MergeFrom(from.playerids_);
  spectatorids_.MergeFrom(from.spectatorids_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_gamemode()) {
      set_gamemode(from.gamemode());
    }
    if (from.has_isprivate()) {
      set_isprivate(from.isprivate());
    }
    if (from.has_adminplayerid()) {
      set_adminplayerid(from.adminplayerid());
    }
    if (from.has_gameinfo()) {
      mutable_gameinfo()->::NetGameInfo::MergeFrom(from.gameinfo());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameListNewMessage::CopyFrom(const GameListNewMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameListNewMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000037) != 0x00000037) return false;

  if (has_gameinfo()) {
    if (!this->gameinfo().IsInitialized()) return false;
  }
  return true;
}

void GameListNewMessage::Swap(GameListNewMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(gamemode_, other->gamemode_);
    std::swap(isprivate_, other->isprivate_);
    playerids_.Swap(&other->playerids_);
    std::swap(adminplayerid_, other->adminplayerid_);
    std::swap(gameinfo_, other->gameinfo_);
    spectatorids_.Swap(&other->spectatorids_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameListNewMessage::GetTypeName() const {
  return "GameListNewMessage";
}


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

#ifndef _MSC_VER
const int GameListUpdateMessage::kGameIdFieldNumber;
const int GameListUpdateMessage::kGameModeFieldNumber;
#endif  // !_MSC_VER

GameListUpdateMessage::GameListUpdateMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameListUpdateMessage)
}

void GameListUpdateMessage::InitAsDefaultInstance() {
}

GameListUpdateMessage::GameListUpdateMessage(const GameListUpdateMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameListUpdateMessage)
}

void GameListUpdateMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  gamemode_ = 1;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameListUpdateMessage::~GameListUpdateMessage() {
  // @@protoc_insertion_point(destructor:GameListUpdateMessage)
  SharedDtor();
}

void GameListUpdateMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameListUpdateMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameListUpdateMessage& GameListUpdateMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameListUpdateMessage* GameListUpdateMessage::default_instance_ = NULL;

GameListUpdateMessage* GameListUpdateMessage::New() const {
  return new GameListUpdateMessage;
}

void GameListUpdateMessage::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    gameid_ = 0u;
    gamemode_ = 1;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameListUpdateMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameListUpdateMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_gameMode;
        break;
      }

      // required .NetGameMode gameMode = 2;
      case 2: {
        if (tag == 16) {
         parse_gameMode:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetGameMode_IsValid(value)) {
            set_gamemode(static_cast< ::NetGameMode >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameListUpdateMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameListUpdateMessage)
  return false;
#undef DO_
}

void GameListUpdateMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameListUpdateMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required .NetGameMode gameMode = 2;
  if (has_gamemode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->gamemode(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameListUpdateMessage)
}

int GameListUpdateMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required .NetGameMode gameMode = 2;
    if (has_gamemode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->gamemode());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameListUpdateMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameListUpdateMessage*>(&from));
}

void GameListUpdateMessage::MergeFrom(const GameListUpdateMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_gamemode()) {
      set_gamemode(from.gamemode());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameListUpdateMessage::CopyFrom(const GameListUpdateMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameListUpdateMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void GameListUpdateMessage::Swap(GameListUpdateMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(gamemode_, other->gamemode_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameListUpdateMessage::GetTypeName() const {
  return "GameListUpdateMessage";
}


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

#ifndef _MSC_VER
const int GameListPlayerJoinedMessage::kGameIdFieldNumber;
const int GameListPlayerJoinedMessage::kPlayerIdFieldNumber;
#endif  // !_MSC_VER

GameListPlayerJoinedMessage::GameListPlayerJoinedMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameListPlayerJoinedMessage)
}

void GameListPlayerJoinedMessage::InitAsDefaultInstance() {
}

GameListPlayerJoinedMessage::GameListPlayerJoinedMessage(const GameListPlayerJoinedMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameListPlayerJoinedMessage)
}

void GameListPlayerJoinedMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameListPlayerJoinedMessage::~GameListPlayerJoinedMessage() {
  // @@protoc_insertion_point(destructor:GameListPlayerJoinedMessage)
  SharedDtor();
}

void GameListPlayerJoinedMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameListPlayerJoinedMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameListPlayerJoinedMessage& GameListPlayerJoinedMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameListPlayerJoinedMessage* GameListPlayerJoinedMessage::default_instance_ = NULL;

GameListPlayerJoinedMessage* GameListPlayerJoinedMessage::New() const {
  return new GameListPlayerJoinedMessage;
}

void GameListPlayerJoinedMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameListPlayerJoinedMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameListPlayerJoinedMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameListPlayerJoinedMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameListPlayerJoinedMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameListPlayerJoinedMessage)
  return false;
#undef DO_
}

void GameListPlayerJoinedMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameListPlayerJoinedMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameListPlayerJoinedMessage)
}

int GameListPlayerJoinedMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameListPlayerJoinedMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameListPlayerJoinedMessage*>(&from));
}

void GameListPlayerJoinedMessage::MergeFrom(const GameListPlayerJoinedMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameListPlayerJoinedMessage::CopyFrom(const GameListPlayerJoinedMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameListPlayerJoinedMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void GameListPlayerJoinedMessage::Swap(GameListPlayerJoinedMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameListPlayerJoinedMessage::GetTypeName() const {
  return "GameListPlayerJoinedMessage";
}


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

#ifndef _MSC_VER
const int GameListPlayerLeftMessage::kGameIdFieldNumber;
const int GameListPlayerLeftMessage::kPlayerIdFieldNumber;
#endif  // !_MSC_VER

GameListPlayerLeftMessage::GameListPlayerLeftMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameListPlayerLeftMessage)
}

void GameListPlayerLeftMessage::InitAsDefaultInstance() {
}

GameListPlayerLeftMessage::GameListPlayerLeftMessage(const GameListPlayerLeftMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameListPlayerLeftMessage)
}

void GameListPlayerLeftMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameListPlayerLeftMessage::~GameListPlayerLeftMessage() {
  // @@protoc_insertion_point(destructor:GameListPlayerLeftMessage)
  SharedDtor();
}

void GameListPlayerLeftMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameListPlayerLeftMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameListPlayerLeftMessage& GameListPlayerLeftMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameListPlayerLeftMessage* GameListPlayerLeftMessage::default_instance_ = NULL;

GameListPlayerLeftMessage* GameListPlayerLeftMessage::New() const {
  return new GameListPlayerLeftMessage;
}

void GameListPlayerLeftMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameListPlayerLeftMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameListPlayerLeftMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameListPlayerLeftMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameListPlayerLeftMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameListPlayerLeftMessage)
  return false;
#undef DO_
}

void GameListPlayerLeftMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameListPlayerLeftMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameListPlayerLeftMessage)
}

int GameListPlayerLeftMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameListPlayerLeftMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameListPlayerLeftMessage*>(&from));
}

void GameListPlayerLeftMessage::MergeFrom(const GameListPlayerLeftMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameListPlayerLeftMessage::CopyFrom(const GameListPlayerLeftMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameListPlayerLeftMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void GameListPlayerLeftMessage::Swap(GameListPlayerLeftMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameListPlayerLeftMessage::GetTypeName() const {
  return "GameListPlayerLeftMessage";
}


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

#ifndef _MSC_VER
const int GameListSpectatorJoinedMessage::kGameIdFieldNumber;
const int GameListSpectatorJoinedMessage::kPlayerIdFieldNumber;
#endif  // !_MSC_VER

GameListSpectatorJoinedMessage::GameListSpectatorJoinedMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameListSpectatorJoinedMessage)
}

void GameListSpectatorJoinedMessage::InitAsDefaultInstance() {
}

GameListSpectatorJoinedMessage::GameListSpectatorJoinedMessage(const GameListSpectatorJoinedMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameListSpectatorJoinedMessage)
}

void GameListSpectatorJoinedMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameListSpectatorJoinedMessage::~GameListSpectatorJoinedMessage() {
  // @@protoc_insertion_point(destructor:GameListSpectatorJoinedMessage)
  SharedDtor();
}

void GameListSpectatorJoinedMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameListSpectatorJoinedMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameListSpectatorJoinedMessage& GameListSpectatorJoinedMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameListSpectatorJoinedMessage* GameListSpectatorJoinedMessage::default_instance_ = NULL;

GameListSpectatorJoinedMessage* GameListSpectatorJoinedMessage::New() const {
  return new GameListSpectatorJoinedMessage;
}

void GameListSpectatorJoinedMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameListSpectatorJoinedMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameListSpectatorJoinedMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameListSpectatorJoinedMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameListSpectatorJoinedMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameListSpectatorJoinedMessage)
  return false;
#undef DO_
}

void GameListSpectatorJoinedMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameListSpectatorJoinedMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameListSpectatorJoinedMessage)
}

int GameListSpectatorJoinedMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameListSpectatorJoinedMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameListSpectatorJoinedMessage*>(&from));
}

void GameListSpectatorJoinedMessage::MergeFrom(const GameListSpectatorJoinedMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameListSpectatorJoinedMessage::CopyFrom(const GameListSpectatorJoinedMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameListSpectatorJoinedMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void GameListSpectatorJoinedMessage::Swap(GameListSpectatorJoinedMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameListSpectatorJoinedMessage::GetTypeName() const {
  return "GameListSpectatorJoinedMessage";
}


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

#ifndef _MSC_VER
const int GameListSpectatorLeftMessage::kGameIdFieldNumber;
const int GameListSpectatorLeftMessage::kPlayerIdFieldNumber;
#endif  // !_MSC_VER

GameListSpectatorLeftMessage::GameListSpectatorLeftMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameListSpectatorLeftMessage)
}

void GameListSpectatorLeftMessage::InitAsDefaultInstance() {
}

GameListSpectatorLeftMessage::GameListSpectatorLeftMessage(const GameListSpectatorLeftMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameListSpectatorLeftMessage)
}

void GameListSpectatorLeftMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameListSpectatorLeftMessage::~GameListSpectatorLeftMessage() {
  // @@protoc_insertion_point(destructor:GameListSpectatorLeftMessage)
  SharedDtor();
}

void GameListSpectatorLeftMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameListSpectatorLeftMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameListSpectatorLeftMessage& GameListSpectatorLeftMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameListSpectatorLeftMessage* GameListSpectatorLeftMessage::default_instance_ = NULL;

GameListSpectatorLeftMessage* GameListSpectatorLeftMessage::New() const {
  return new GameListSpectatorLeftMessage;
}

void GameListSpectatorLeftMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameListSpectatorLeftMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameListSpectatorLeftMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameListSpectatorLeftMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameListSpectatorLeftMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameListSpectatorLeftMessage)
  return false;
#undef DO_
}

void GameListSpectatorLeftMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameListSpectatorLeftMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameListSpectatorLeftMessage)
}

int GameListSpectatorLeftMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameListSpectatorLeftMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameListSpectatorLeftMessage*>(&from));
}

void GameListSpectatorLeftMessage::MergeFrom(const GameListSpectatorLeftMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameListSpectatorLeftMessage::CopyFrom(const GameListSpectatorLeftMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameListSpectatorLeftMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void GameListSpectatorLeftMessage::Swap(GameListSpectatorLeftMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameListSpectatorLeftMessage::GetTypeName() const {
  return "GameListSpectatorLeftMessage";
}


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

#ifndef _MSC_VER
const int GameListAdminChangedMessage::kGameIdFieldNumber;
const int GameListAdminChangedMessage::kNewAdminPlayerIdFieldNumber;
#endif  // !_MSC_VER

GameListAdminChangedMessage::GameListAdminChangedMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameListAdminChangedMessage)
}

void GameListAdminChangedMessage::InitAsDefaultInstance() {
}

GameListAdminChangedMessage::GameListAdminChangedMessage(const GameListAdminChangedMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameListAdminChangedMessage)
}

void GameListAdminChangedMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  newadminplayerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameListAdminChangedMessage::~GameListAdminChangedMessage() {
  // @@protoc_insertion_point(destructor:GameListAdminChangedMessage)
  SharedDtor();
}

void GameListAdminChangedMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameListAdminChangedMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameListAdminChangedMessage& GameListAdminChangedMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameListAdminChangedMessage* GameListAdminChangedMessage::default_instance_ = NULL;

GameListAdminChangedMessage* GameListAdminChangedMessage::New() const {
  return new GameListAdminChangedMessage;
}

void GameListAdminChangedMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameListAdminChangedMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, newadminplayerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameListAdminChangedMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameListAdminChangedMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_newAdminPlayerId;
        break;
      }

      // required uint32 newAdminPlayerId = 2;
      case 2: {
        if (tag == 16) {
         parse_newAdminPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &newadminplayerid_)));
          set_has_newadminplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameListAdminChangedMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameListAdminChangedMessage)
  return false;
#undef DO_
}

void GameListAdminChangedMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameListAdminChangedMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 newAdminPlayerId = 2;
  if (has_newadminplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->newadminplayerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameListAdminChangedMessage)
}

int GameListAdminChangedMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 newAdminPlayerId = 2;
    if (has_newadminplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->newadminplayerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameListAdminChangedMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameListAdminChangedMessage*>(&from));
}

void GameListAdminChangedMessage::MergeFrom(const GameListAdminChangedMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_newadminplayerid()) {
      set_newadminplayerid(from.newadminplayerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameListAdminChangedMessage::CopyFrom(const GameListAdminChangedMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameListAdminChangedMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void GameListAdminChangedMessage::Swap(GameListAdminChangedMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(newadminplayerid_, other->newadminplayerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameListAdminChangedMessage::GetTypeName() const {
  return "GameListAdminChangedMessage";
}


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

#ifndef _MSC_VER
const int PlayerInfoRequestMessage::kPlayerIdFieldNumber;
#endif  // !_MSC_VER

PlayerInfoRequestMessage::PlayerInfoRequestMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PlayerInfoRequestMessage)
}

void PlayerInfoRequestMessage::InitAsDefaultInstance() {
}

PlayerInfoRequestMessage::PlayerInfoRequestMessage(const PlayerInfoRequestMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PlayerInfoRequestMessage)
}

void PlayerInfoRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PlayerInfoRequestMessage::~PlayerInfoRequestMessage() {
  // @@protoc_insertion_point(destructor:PlayerInfoRequestMessage)
  SharedDtor();
}

void PlayerInfoRequestMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void PlayerInfoRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PlayerInfoRequestMessage& PlayerInfoRequestMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

PlayerInfoRequestMessage* PlayerInfoRequestMessage::default_instance_ = NULL;

PlayerInfoRequestMessage* PlayerInfoRequestMessage::New() const {
  return new PlayerInfoRequestMessage;
}

void PlayerInfoRequestMessage::Clear() {
  playerid_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PlayerInfoRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PlayerInfoRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated uint32 playerId = 1 [packed = true];
      case 1: {
        if (tag == 10) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_playerid())));
        } else if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 10, input, this->mutable_playerid())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PlayerInfoRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PlayerInfoRequestMessage)
  return false;
#undef DO_
}

void PlayerInfoRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PlayerInfoRequestMessage)
  // repeated uint32 playerId = 1 [packed = true];
  if (this->playerid_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_playerid_cached_byte_size_);
  }
  for (int i = 0; i < this->playerid_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
      this->playerid(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PlayerInfoRequestMessage)
}

int PlayerInfoRequestMessage::ByteSize() const {
  int total_size = 0;

  // repeated uint32 playerId = 1 [packed = true];
  {
    int data_size = 0;
    for (int i = 0; i < this->playerid_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->playerid(i));
    }
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _playerid_cached_byte_size_ = data_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PlayerInfoRequestMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PlayerInfoRequestMessage*>(&from));
}

void PlayerInfoRequestMessage::MergeFrom(const PlayerInfoRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  playerid_.MergeFrom(from.playerid_);
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PlayerInfoRequestMessage::CopyFrom(const PlayerInfoRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlayerInfoRequestMessage::IsInitialized() const {

  return true;
}

void PlayerInfoRequestMessage::Swap(PlayerInfoRequestMessage* other) {
  if (other != this) {
    playerid_.Swap(&other->playerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PlayerInfoRequestMessage::GetTypeName() const {
  return "PlayerInfoRequestMessage";
}


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

#ifndef _MSC_VER
const int PlayerInfoReplyMessage_PlayerInfoData_AvatarData::kAvatarTypeFieldNumber;
const int PlayerInfoReplyMessage_PlayerInfoData_AvatarData::kAvatarHashFieldNumber;
#endif  // !_MSC_VER

PlayerInfoReplyMessage_PlayerInfoData_AvatarData::PlayerInfoReplyMessage_PlayerInfoData_AvatarData()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PlayerInfoReplyMessage.PlayerInfoData.AvatarData)
}

void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::InitAsDefaultInstance() {
}

PlayerInfoReplyMessage_PlayerInfoData_AvatarData::PlayerInfoReplyMessage_PlayerInfoData_AvatarData(const PlayerInfoReplyMessage_PlayerInfoData_AvatarData& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PlayerInfoReplyMessage.PlayerInfoData.AvatarData)
}

void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  avatartype_ = 1;
  avatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PlayerInfoReplyMessage_PlayerInfoData_AvatarData::~PlayerInfoReplyMessage_PlayerInfoData_AvatarData() {
  // @@protoc_insertion_point(destructor:PlayerInfoReplyMessage.PlayerInfoData.AvatarData)
  SharedDtor();
}

void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::SharedDtor() {
  if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete avatarhash_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PlayerInfoReplyMessage_PlayerInfoData_AvatarData& PlayerInfoReplyMessage_PlayerInfoData_AvatarData::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

PlayerInfoReplyMessage_PlayerInfoData_AvatarData* PlayerInfoReplyMessage_PlayerInfoData_AvatarData::default_instance_ = NULL;

PlayerInfoReplyMessage_PlayerInfoData_AvatarData* PlayerInfoReplyMessage_PlayerInfoData_AvatarData::New() const {
  return new PlayerInfoReplyMessage_PlayerInfoData_AvatarData;
}

void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    avatartype_ = 1;
    if (has_avatarhash()) {
      if (avatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        avatarhash_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PlayerInfoReplyMessage_PlayerInfoData_AvatarData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PlayerInfoReplyMessage.PlayerInfoData.AvatarData)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .NetAvatarType avatarType = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetAvatarType_IsValid(value)) {
            set_avatartype(static_cast< ::NetAvatarType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_avatarHash;
        break;
      }

      // required bytes avatarHash = 2;
      case 2: {
        if (tag == 18) {
         parse_avatarHash:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_avatarhash()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PlayerInfoReplyMessage.PlayerInfoData.AvatarData)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PlayerInfoReplyMessage.PlayerInfoData.AvatarData)
  return false;
#undef DO_
}

void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PlayerInfoReplyMessage.PlayerInfoData.AvatarData)
  // required .NetAvatarType avatarType = 1;
  if (has_avatartype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->avatartype(), output);
  }

  // required bytes avatarHash = 2;
  if (has_avatarhash()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->avatarhash(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PlayerInfoReplyMessage.PlayerInfoData.AvatarData)
}

int PlayerInfoReplyMessage_PlayerInfoData_AvatarData::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .NetAvatarType avatarType = 1;
    if (has_avatartype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->avatartype());
    }

    // required bytes avatarHash = 2;
    if (has_avatarhash()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->avatarhash());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PlayerInfoReplyMessage_PlayerInfoData_AvatarData*>(&from));
}

void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::MergeFrom(const PlayerInfoReplyMessage_PlayerInfoData_AvatarData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_avatartype()) {
      set_avatartype(from.avatartype());
    }
    if (from.has_avatarhash()) {
      set_avatarhash(from.avatarhash());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::CopyFrom(const PlayerInfoReplyMessage_PlayerInfoData_AvatarData& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlayerInfoReplyMessage_PlayerInfoData_AvatarData::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void PlayerInfoReplyMessage_PlayerInfoData_AvatarData::Swap(PlayerInfoReplyMessage_PlayerInfoData_AvatarData* other) {
  if (other != this) {
    std::swap(avatartype_, other->avatartype_);
    std::swap(avatarhash_, other->avatarhash_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PlayerInfoReplyMessage_PlayerInfoData_AvatarData::GetTypeName() const {
  return "PlayerInfoReplyMessage.PlayerInfoData.AvatarData";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int PlayerInfoReplyMessage_PlayerInfoData::kPlayerNameFieldNumber;
const int PlayerInfoReplyMessage_PlayerInfoData::kIsHumanFieldNumber;
const int PlayerInfoReplyMessage_PlayerInfoData::kPlayerRightsFieldNumber;
const int PlayerInfoReplyMessage_PlayerInfoData::kCountryCodeFieldNumber;
const int PlayerInfoReplyMessage_PlayerInfoData::kAvatarDataFieldNumber;
#endif  // !_MSC_VER

PlayerInfoReplyMessage_PlayerInfoData::PlayerInfoReplyMessage_PlayerInfoData()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PlayerInfoReplyMessage.PlayerInfoData)
}

void PlayerInfoReplyMessage_PlayerInfoData::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  avatardata_ = const_cast< ::PlayerInfoReplyMessage_PlayerInfoData_AvatarData*>(
      ::PlayerInfoReplyMessage_PlayerInfoData_AvatarData::internal_default_instance());
#else
  avatardata_ = const_cast< ::PlayerInfoReplyMessage_PlayerInfoData_AvatarData*>(&::PlayerInfoReplyMessage_PlayerInfoData_AvatarData::default_instance());
#endif
}

PlayerInfoReplyMessage_PlayerInfoData::PlayerInfoReplyMessage_PlayerInfoData(const PlayerInfoReplyMessage_PlayerInfoData& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PlayerInfoReplyMessage.PlayerInfoData)
}

void PlayerInfoReplyMessage_PlayerInfoData::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ishuman_ = false;
  playerrights_ = 1;
  countrycode_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  avatardata_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PlayerInfoReplyMessage_PlayerInfoData::~PlayerInfoReplyMessage_PlayerInfoData() {
  // @@protoc_insertion_point(destructor:PlayerInfoReplyMessage.PlayerInfoData)
  SharedDtor();
}

void PlayerInfoReplyMessage_PlayerInfoData::SharedDtor() {
  if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete playername_;
  }
  if (countrycode_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete countrycode_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete avatardata_;
  }
}

void PlayerInfoReplyMessage_PlayerInfoData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PlayerInfoReplyMessage_PlayerInfoData& PlayerInfoReplyMessage_PlayerInfoData::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

PlayerInfoReplyMessage_PlayerInfoData* PlayerInfoReplyMessage_PlayerInfoData::default_instance_ = NULL;

PlayerInfoReplyMessage_PlayerInfoData* PlayerInfoReplyMessage_PlayerInfoData::New() const {
  return new PlayerInfoReplyMessage_PlayerInfoData;
}

void PlayerInfoReplyMessage_PlayerInfoData::Clear() {
  if (_has_bits_[0 / 32] & 31) {
    if (has_playername()) {
      if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        playername_->clear();
      }
    }
    ishuman_ = false;
    playerrights_ = 1;
    if (has_countrycode()) {
      if (countrycode_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        countrycode_->clear();
      }
    }
    if (has_avatardata()) {
      if (avatardata_ != NULL) avatardata_->::PlayerInfoReplyMessage_PlayerInfoData_AvatarData::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PlayerInfoReplyMessage_PlayerInfoData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PlayerInfoReplyMessage.PlayerInfoData)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string playerName = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_playername()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_isHuman;
        break;
      }

      // required bool isHuman = 2;
      case 2: {
        if (tag == 16) {
         parse_isHuman:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ishuman_)));
          set_has_ishuman();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_playerRights;
        break;
      }

      // required .NetPlayerInfoRights playerRights = 3;
      case 3: {
        if (tag == 24) {
         parse_playerRights:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetPlayerInfoRights_IsValid(value)) {
            set_playerrights(static_cast< ::NetPlayerInfoRights >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_countryCode;
        break;
      }

      // optional string countryCode = 4;
      case 4: {
        if (tag == 34) {
         parse_countryCode:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_countrycode()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_avatarData;
        break;
      }

      // optional .PlayerInfoReplyMessage.PlayerInfoData.AvatarData avatarData = 5;
      case 5: {
        if (tag == 42) {
         parse_avatarData:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_avatardata()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PlayerInfoReplyMessage.PlayerInfoData)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PlayerInfoReplyMessage.PlayerInfoData)
  return false;
#undef DO_
}

void PlayerInfoReplyMessage_PlayerInfoData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PlayerInfoReplyMessage.PlayerInfoData)
  // required string playerName = 1;
  if (has_playername()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->playername(), output);
  }

  // required bool isHuman = 2;
  if (has_ishuman()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->ishuman(), output);
  }

  // required .NetPlayerInfoRights playerRights = 3;
  if (has_playerrights()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->playerrights(), output);
  }

  // optional string countryCode = 4;
  if (has_countrycode()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->countrycode(), output);
  }

  // optional .PlayerInfoReplyMessage.PlayerInfoData.AvatarData avatarData = 5;
  if (has_avatardata()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, this->avatardata(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PlayerInfoReplyMessage.PlayerInfoData)
}

int PlayerInfoReplyMessage_PlayerInfoData::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string playerName = 1;
    if (has_playername()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->playername());
    }

    // required bool isHuman = 2;
    if (has_ishuman()) {
      total_size += 1 + 1;
    }

    // required .NetPlayerInfoRights playerRights = 3;
    if (has_playerrights()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->playerrights());
    }

    // optional string countryCode = 4;
    if (has_countrycode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->countrycode());
    }

    // optional .PlayerInfoReplyMessage.PlayerInfoData.AvatarData avatarData = 5;
    if (has_avatardata()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->avatardata());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PlayerInfoReplyMessage_PlayerInfoData::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PlayerInfoReplyMessage_PlayerInfoData*>(&from));
}

void PlayerInfoReplyMessage_PlayerInfoData::MergeFrom(const PlayerInfoReplyMessage_PlayerInfoData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_playername()) {
      set_playername(from.playername());
    }
    if (from.has_ishuman()) {
      set_ishuman(from.ishuman());
    }
    if (from.has_playerrights()) {
      set_playerrights(from.playerrights());
    }
    if (from.has_countrycode()) {
      set_countrycode(from.countrycode());
    }
    if (from.has_avatardata()) {
      mutable_avatardata()->::PlayerInfoReplyMessage_PlayerInfoData_AvatarData::MergeFrom(from.avatardata());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PlayerInfoReplyMessage_PlayerInfoData::CopyFrom(const PlayerInfoReplyMessage_PlayerInfoData& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlayerInfoReplyMessage_PlayerInfoData::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  if (has_avatardata()) {
    if (!this->avatardata().IsInitialized()) return false;
  }
  return true;
}

void PlayerInfoReplyMessage_PlayerInfoData::Swap(PlayerInfoReplyMessage_PlayerInfoData* other) {
  if (other != this) {
    std::swap(playername_, other->playername_);
    std::swap(ishuman_, other->ishuman_);
    std::swap(playerrights_, other->playerrights_);
    std::swap(countrycode_, other->countrycode_);
    std::swap(avatardata_, other->avatardata_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PlayerInfoReplyMessage_PlayerInfoData::GetTypeName() const {
  return "PlayerInfoReplyMessage.PlayerInfoData";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int PlayerInfoReplyMessage::kPlayerIdFieldNumber;
const int PlayerInfoReplyMessage::kPlayerInfoDataFieldNumber;
#endif  // !_MSC_VER

PlayerInfoReplyMessage::PlayerInfoReplyMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PlayerInfoReplyMessage)
}

void PlayerInfoReplyMessage::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  playerinfodata_ = const_cast< ::PlayerInfoReplyMessage_PlayerInfoData*>(
      ::PlayerInfoReplyMessage_PlayerInfoData::internal_default_instance());
#else
  playerinfodata_ = const_cast< ::PlayerInfoReplyMessage_PlayerInfoData*>(&::PlayerInfoReplyMessage_PlayerInfoData::default_instance());
#endif
}

PlayerInfoReplyMessage::PlayerInfoReplyMessage(const PlayerInfoReplyMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PlayerInfoReplyMessage)
}

void PlayerInfoReplyMessage::SharedCtor() {
  _cached_size_ = 0;
  playerid_ = 0u;
  playerinfodata_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PlayerInfoReplyMessage::~PlayerInfoReplyMessage() {
  // @@protoc_insertion_point(destructor:PlayerInfoReplyMessage)
  SharedDtor();
}

void PlayerInfoReplyMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete playerinfodata_;
  }
}

void PlayerInfoReplyMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PlayerInfoReplyMessage& PlayerInfoReplyMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

PlayerInfoReplyMessage* PlayerInfoReplyMessage::default_instance_ = NULL;

PlayerInfoReplyMessage* PlayerInfoReplyMessage::New() const {
  return new PlayerInfoReplyMessage;
}

void PlayerInfoReplyMessage::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    playerid_ = 0u;
    if (has_playerinfodata()) {
      if (playerinfodata_ != NULL) playerinfodata_->::PlayerInfoReplyMessage_PlayerInfoData::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PlayerInfoReplyMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PlayerInfoReplyMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 playerId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_playerInfoData;
        break;
      }

      // optional .PlayerInfoReplyMessage.PlayerInfoData playerInfoData = 2;
      case 2: {
        if (tag == 18) {
         parse_playerInfoData:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_playerinfodata()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PlayerInfoReplyMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PlayerInfoReplyMessage)
  return false;
#undef DO_
}

void PlayerInfoReplyMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PlayerInfoReplyMessage)
  // required uint32 playerId = 1;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output);
  }

  // optional .PlayerInfoReplyMessage.PlayerInfoData playerInfoData = 2;
  if (has_playerinfodata()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->playerinfodata(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PlayerInfoReplyMessage)
}

int PlayerInfoReplyMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 playerId = 1;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // optional .PlayerInfoReplyMessage.PlayerInfoData playerInfoData = 2;
    if (has_playerinfodata()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->playerinfodata());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PlayerInfoReplyMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PlayerInfoReplyMessage*>(&from));
}

void PlayerInfoReplyMessage::MergeFrom(const PlayerInfoReplyMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_playerinfodata()) {
      mutable_playerinfodata()->::PlayerInfoReplyMessage_PlayerInfoData::MergeFrom(from.playerinfodata());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PlayerInfoReplyMessage::CopyFrom(const PlayerInfoReplyMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlayerInfoReplyMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_playerinfodata()) {
    if (!this->playerinfodata().IsInitialized()) return false;
  }
  return true;
}

void PlayerInfoReplyMessage::Swap(PlayerInfoReplyMessage* other) {
  if (other != this) {
    std::swap(playerid_, other->playerid_);
    std::swap(playerinfodata_, other->playerinfodata_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PlayerInfoReplyMessage::GetTypeName() const {
  return "PlayerInfoReplyMessage";
}


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

bool SubscriptionRequestMessage_SubscriptionAction_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const SubscriptionRequestMessage_SubscriptionAction SubscriptionRequestMessage::unsubscribeGameList;
const SubscriptionRequestMessage_SubscriptionAction SubscriptionRequestMessage::resubscribeGameList;
const SubscriptionRequestMessage_SubscriptionAction SubscriptionRequestMessage::SubscriptionAction_MIN;
const SubscriptionRequestMessage_SubscriptionAction SubscriptionRequestMessage::SubscriptionAction_MAX;
const int SubscriptionRequestMessage::SubscriptionAction_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int SubscriptionRequestMessage::kSubscriptionActionFieldNumber;
#endif  // !_MSC_VER

SubscriptionRequestMessage::SubscriptionRequestMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SubscriptionRequestMessage)
}

void SubscriptionRequestMessage::InitAsDefaultInstance() {
}

SubscriptionRequestMessage::SubscriptionRequestMessage(const SubscriptionRequestMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:SubscriptionRequestMessage)
}

void SubscriptionRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  subscriptionaction_ = 1;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SubscriptionRequestMessage::~SubscriptionRequestMessage() {
  // @@protoc_insertion_point(destructor:SubscriptionRequestMessage)
  SharedDtor();
}

void SubscriptionRequestMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void SubscriptionRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const SubscriptionRequestMessage& SubscriptionRequestMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

SubscriptionRequestMessage* SubscriptionRequestMessage::default_instance_ = NULL;

SubscriptionRequestMessage* SubscriptionRequestMessage::New() const {
  return new SubscriptionRequestMessage;
}

void SubscriptionRequestMessage::Clear() {
  subscriptionaction_ = 1;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool SubscriptionRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:SubscriptionRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .SubscriptionRequestMessage.SubscriptionAction subscriptionAction = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::SubscriptionRequestMessage_SubscriptionAction_IsValid(value)) {
            set_subscriptionaction(static_cast< ::SubscriptionRequestMessage_SubscriptionAction >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:SubscriptionRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:SubscriptionRequestMessage)
  return false;
#undef DO_
}

void SubscriptionRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:SubscriptionRequestMessage)
  // required .SubscriptionRequestMessage.SubscriptionAction subscriptionAction = 1;
  if (has_subscriptionaction()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->subscriptionaction(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:SubscriptionRequestMessage)
}

int SubscriptionRequestMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .SubscriptionRequestMessage.SubscriptionAction subscriptionAction = 1;
    if (has_subscriptionaction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->subscriptionaction());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SubscriptionRequestMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const SubscriptionRequestMessage*>(&from));
}

void SubscriptionRequestMessage::MergeFrom(const SubscriptionRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_subscriptionaction()) {
      set_subscriptionaction(from.subscriptionaction());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void SubscriptionRequestMessage::CopyFrom(const SubscriptionRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SubscriptionRequestMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void SubscriptionRequestMessage::Swap(SubscriptionRequestMessage* other) {
  if (other != this) {
    std::swap(subscriptionaction_, other->subscriptionaction_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string SubscriptionRequestMessage::GetTypeName() const {
  return "SubscriptionRequestMessage";
}


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

#ifndef _MSC_VER
const int JoinExistingGameMessage::kGameIdFieldNumber;
const int JoinExistingGameMessage::kPasswordFieldNumber;
const int JoinExistingGameMessage::kAutoLeaveFieldNumber;
const int JoinExistingGameMessage::kSpectateOnlyFieldNumber;
#endif  // !_MSC_VER

JoinExistingGameMessage::JoinExistingGameMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:JoinExistingGameMessage)
}

void JoinExistingGameMessage::InitAsDefaultInstance() {
}

JoinExistingGameMessage::JoinExistingGameMessage(const JoinExistingGameMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:JoinExistingGameMessage)
}

void JoinExistingGameMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  gameid_ = 0u;
  password_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  autoleave_ = false;
  spectateonly_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

JoinExistingGameMessage::~JoinExistingGameMessage() {
  // @@protoc_insertion_point(destructor:JoinExistingGameMessage)
  SharedDtor();
}

void JoinExistingGameMessage::SharedDtor() {
  if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete password_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void JoinExistingGameMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const JoinExistingGameMessage& JoinExistingGameMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

JoinExistingGameMessage* JoinExistingGameMessage::default_instance_ = NULL;

JoinExistingGameMessage* JoinExistingGameMessage::New() const {
  return new JoinExistingGameMessage;
}

void JoinExistingGameMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<JoinExistingGameMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(gameid_, spectateonly_);
    if (has_password()) {
      if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        password_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool JoinExistingGameMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:JoinExistingGameMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_password;
        break;
      }

      // optional string password = 2;
      case 2: {
        if (tag == 18) {
         parse_password:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_password()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_autoLeave;
        break;
      }

      // optional bool autoLeave = 3 [default = false];
      case 3: {
        if (tag == 24) {
         parse_autoLeave:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &autoleave_)));
          set_has_autoleave();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_spectateOnly;
        break;
      }

      // optional bool spectateOnly = 4 [default = false];
      case 4: {
        if (tag == 32) {
         parse_spectateOnly:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &spectateonly_)));
          set_has_spectateonly();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:JoinExistingGameMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:JoinExistingGameMessage)
  return false;
#undef DO_
}

void JoinExistingGameMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:JoinExistingGameMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // optional string password = 2;
  if (has_password()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->password(), output);
  }

  // optional bool autoLeave = 3 [default = false];
  if (has_autoleave()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->autoleave(), output);
  }

  // optional bool spectateOnly = 4 [default = false];
  if (has_spectateonly()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->spectateonly(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:JoinExistingGameMessage)
}

int JoinExistingGameMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // optional string password = 2;
    if (has_password()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->password());
    }

    // optional bool autoLeave = 3 [default = false];
    if (has_autoleave()) {
      total_size += 1 + 1;
    }

    // optional bool spectateOnly = 4 [default = false];
    if (has_spectateonly()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void JoinExistingGameMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const JoinExistingGameMessage*>(&from));
}

void JoinExistingGameMessage::MergeFrom(const JoinExistingGameMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_password()) {
      set_password(from.password());
    }
    if (from.has_autoleave()) {
      set_autoleave(from.autoleave());
    }
    if (from.has_spectateonly()) {
      set_spectateonly(from.spectateonly());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void JoinExistingGameMessage::CopyFrom(const JoinExistingGameMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool JoinExistingGameMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void JoinExistingGameMessage::Swap(JoinExistingGameMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(password_, other->password_);
    std::swap(autoleave_, other->autoleave_);
    std::swap(spectateonly_, other->spectateonly_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string JoinExistingGameMessage::GetTypeName() const {
  return "JoinExistingGameMessage";
}


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

#ifndef _MSC_VER
const int JoinNewGameMessage::kGameInfoFieldNumber;
const int JoinNewGameMessage::kPasswordFieldNumber;
const int JoinNewGameMessage::kAutoLeaveFieldNumber;
#endif  // !_MSC_VER

JoinNewGameMessage::JoinNewGameMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:JoinNewGameMessage)
}

void JoinNewGameMessage::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gameinfo_ = const_cast< ::NetGameInfo*>(
      ::NetGameInfo::internal_default_instance());
#else
  gameinfo_ = const_cast< ::NetGameInfo*>(&::NetGameInfo::default_instance());
#endif
}

JoinNewGameMessage::JoinNewGameMessage(const JoinNewGameMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:JoinNewGameMessage)
}

void JoinNewGameMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  gameinfo_ = NULL;
  password_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  autoleave_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

JoinNewGameMessage::~JoinNewGameMessage() {
  // @@protoc_insertion_point(destructor:JoinNewGameMessage)
  SharedDtor();
}

void JoinNewGameMessage::SharedDtor() {
  if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete password_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete gameinfo_;
  }
}

void JoinNewGameMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const JoinNewGameMessage& JoinNewGameMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

JoinNewGameMessage* JoinNewGameMessage::default_instance_ = NULL;

JoinNewGameMessage* JoinNewGameMessage::New() const {
  return new JoinNewGameMessage;
}

void JoinNewGameMessage::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    if (has_gameinfo()) {
      if (gameinfo_ != NULL) gameinfo_->::NetGameInfo::Clear();
    }
    if (has_password()) {
      if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        password_->clear();
      }
    }
    autoleave_ = false;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool JoinNewGameMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:JoinNewGameMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .NetGameInfo gameInfo = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gameinfo()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_password;
        break;
      }

      // optional string password = 2;
      case 2: {
        if (tag == 18) {
         parse_password:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_password()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_autoLeave;
        break;
      }

      // optional bool autoLeave = 3;
      case 3: {
        if (tag == 24) {
         parse_autoLeave:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &autoleave_)));
          set_has_autoleave();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:JoinNewGameMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:JoinNewGameMessage)
  return false;
#undef DO_
}

void JoinNewGameMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:JoinNewGameMessage)
  // required .NetGameInfo gameInfo = 1;
  if (has_gameinfo()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->gameinfo(), output);
  }

  // optional string password = 2;
  if (has_password()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->password(), output);
  }

  // optional bool autoLeave = 3;
  if (has_autoleave()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->autoleave(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:JoinNewGameMessage)
}

int JoinNewGameMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .NetGameInfo gameInfo = 1;
    if (has_gameinfo()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gameinfo());
    }

    // optional string password = 2;
    if (has_password()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->password());
    }

    // optional bool autoLeave = 3;
    if (has_autoleave()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void JoinNewGameMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const JoinNewGameMessage*>(&from));
}

void JoinNewGameMessage::MergeFrom(const JoinNewGameMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameinfo()) {
      mutable_gameinfo()->::NetGameInfo::MergeFrom(from.gameinfo());
    }
    if (from.has_password()) {
      set_password(from.password());
    }
    if (from.has_autoleave()) {
      set_autoleave(from.autoleave());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void JoinNewGameMessage::CopyFrom(const JoinNewGameMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool JoinNewGameMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_gameinfo()) {
    if (!this->gameinfo().IsInitialized()) return false;
  }
  return true;
}

void JoinNewGameMessage::Swap(JoinNewGameMessage* other) {
  if (other != this) {
    std::swap(gameinfo_, other->gameinfo_);
    std::swap(password_, other->password_);
    std::swap(autoleave_, other->autoleave_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string JoinNewGameMessage::GetTypeName() const {
  return "JoinNewGameMessage";
}


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

#ifndef _MSC_VER
const int RejoinExistingGameMessage::kGameIdFieldNumber;
const int RejoinExistingGameMessage::kAutoLeaveFieldNumber;
#endif  // !_MSC_VER

RejoinExistingGameMessage::RejoinExistingGameMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:RejoinExistingGameMessage)
}

void RejoinExistingGameMessage::InitAsDefaultInstance() {
}

RejoinExistingGameMessage::RejoinExistingGameMessage(const RejoinExistingGameMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:RejoinExistingGameMessage)
}

void RejoinExistingGameMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  autoleave_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RejoinExistingGameMessage::~RejoinExistingGameMessage() {
  // @@protoc_insertion_point(destructor:RejoinExistingGameMessage)
  SharedDtor();
}

void RejoinExistingGameMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void RejoinExistingGameMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RejoinExistingGameMessage& RejoinExistingGameMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

RejoinExistingGameMessage* RejoinExistingGameMessage::default_instance_ = NULL;

RejoinExistingGameMessage* RejoinExistingGameMessage::New() const {
  return new RejoinExistingGameMessage;
}

void RejoinExistingGameMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<RejoinExistingGameMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, autoleave_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool RejoinExistingGameMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:RejoinExistingGameMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_autoLeave;
        break;
      }

      // optional bool autoLeave = 2;
      case 2: {
        if (tag == 16) {
         parse_autoLeave:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &autoleave_)));
          set_has_autoleave();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:RejoinExistingGameMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:RejoinExistingGameMessage)
  return false;
#undef DO_
}

void RejoinExistingGameMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:RejoinExistingGameMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // optional bool autoLeave = 2;
  if (has_autoleave()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->autoleave(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:RejoinExistingGameMessage)
}

int RejoinExistingGameMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // optional bool autoLeave = 2;
    if (has_autoleave()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RejoinExistingGameMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RejoinExistingGameMessage*>(&from));
}

void RejoinExistingGameMessage::MergeFrom(const RejoinExistingGameMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_autoleave()) {
      set_autoleave(from.autoleave());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void RejoinExistingGameMessage::CopyFrom(const RejoinExistingGameMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RejoinExistingGameMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void RejoinExistingGameMessage::Swap(RejoinExistingGameMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(autoleave_, other->autoleave_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string RejoinExistingGameMessage::GetTypeName() const {
  return "RejoinExistingGameMessage";
}


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

#ifndef _MSC_VER
const int JoinGameAckMessage::kGameIdFieldNumber;
const int JoinGameAckMessage::kAreYouGameAdminFieldNumber;
const int JoinGameAckMessage::kGameInfoFieldNumber;
const int JoinGameAckMessage::kSpectateOnlyFieldNumber;
#endif  // !_MSC_VER

JoinGameAckMessage::JoinGameAckMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:JoinGameAckMessage)
}

void JoinGameAckMessage::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gameinfo_ = const_cast< ::NetGameInfo*>(
      ::NetGameInfo::internal_default_instance());
#else
  gameinfo_ = const_cast< ::NetGameInfo*>(&::NetGameInfo::default_instance());
#endif
}

JoinGameAckMessage::JoinGameAckMessage(const JoinGameAckMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:JoinGameAckMessage)
}

void JoinGameAckMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  areyougameadmin_ = false;
  gameinfo_ = NULL;
  spectateonly_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

JoinGameAckMessage::~JoinGameAckMessage() {
  // @@protoc_insertion_point(destructor:JoinGameAckMessage)
  SharedDtor();
}

void JoinGameAckMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete gameinfo_;
  }
}

void JoinGameAckMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const JoinGameAckMessage& JoinGameAckMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

JoinGameAckMessage* JoinGameAckMessage::default_instance_ = NULL;

JoinGameAckMessage* JoinGameAckMessage::New() const {
  return new JoinGameAckMessage;
}

void JoinGameAckMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<JoinGameAckMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(gameid_, spectateonly_);
    if (has_gameinfo()) {
      if (gameinfo_ != NULL) gameinfo_->::NetGameInfo::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool JoinGameAckMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:JoinGameAckMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_areYouGameAdmin;
        break;
      }

      // required bool areYouGameAdmin = 2;
      case 2: {
        if (tag == 16) {
         parse_areYouGameAdmin:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &areyougameadmin_)));
          set_has_areyougameadmin();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_gameInfo;
        break;
      }

      // required .NetGameInfo gameInfo = 3;
      case 3: {
        if (tag == 26) {
         parse_gameInfo:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gameinfo()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_spectateOnly;
        break;
      }

      // optional bool spectateOnly = 4;
      case 4: {
        if (tag == 32) {
         parse_spectateOnly:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &spectateonly_)));
          set_has_spectateonly();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:JoinGameAckMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:JoinGameAckMessage)
  return false;
#undef DO_
}

void JoinGameAckMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:JoinGameAckMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required bool areYouGameAdmin = 2;
  if (has_areyougameadmin()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->areyougameadmin(), output);
  }

  // required .NetGameInfo gameInfo = 3;
  if (has_gameinfo()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->gameinfo(), output);
  }

  // optional bool spectateOnly = 4;
  if (has_spectateonly()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->spectateonly(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:JoinGameAckMessage)
}

int JoinGameAckMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required bool areYouGameAdmin = 2;
    if (has_areyougameadmin()) {
      total_size += 1 + 1;
    }

    // required .NetGameInfo gameInfo = 3;
    if (has_gameinfo()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gameinfo());
    }

    // optional bool spectateOnly = 4;
    if (has_spectateonly()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void JoinGameAckMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const JoinGameAckMessage*>(&from));
}

void JoinGameAckMessage::MergeFrom(const JoinGameAckMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_areyougameadmin()) {
      set_areyougameadmin(from.areyougameadmin());
    }
    if (from.has_gameinfo()) {
      mutable_gameinfo()->::NetGameInfo::MergeFrom(from.gameinfo());
    }
    if (from.has_spectateonly()) {
      set_spectateonly(from.spectateonly());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void JoinGameAckMessage::CopyFrom(const JoinGameAckMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool JoinGameAckMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  if (has_gameinfo()) {
    if (!this->gameinfo().IsInitialized()) return false;
  }
  return true;
}

void JoinGameAckMessage::Swap(JoinGameAckMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(areyougameadmin_, other->areyougameadmin_);
    std::swap(gameinfo_, other->gameinfo_);
    std::swap(spectateonly_, other->spectateonly_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string JoinGameAckMessage::GetTypeName() const {
  return "JoinGameAckMessage";
}


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

bool JoinGameFailedMessage_JoinGameFailureReason_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::invalidGame;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::gameIsFull;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::gameIsRunning;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::invalidPassword;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::notAllowedAsGuest;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::notInvited;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::gameNameInUse;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::badGameName;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::invalidSettings;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::ipAddressBlocked;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::rejoinFailed;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::noSpectatorsAllowed;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::JoinGameFailureReason_MIN;
const JoinGameFailedMessage_JoinGameFailureReason JoinGameFailedMessage::JoinGameFailureReason_MAX;
const int JoinGameFailedMessage::JoinGameFailureReason_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int JoinGameFailedMessage::kGameIdFieldNumber;
const int JoinGameFailedMessage::kJoinGameFailureReasonFieldNumber;
#endif  // !_MSC_VER

JoinGameFailedMessage::JoinGameFailedMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:JoinGameFailedMessage)
}

void JoinGameFailedMessage::InitAsDefaultInstance() {
}

JoinGameFailedMessage::JoinGameFailedMessage(const JoinGameFailedMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:JoinGameFailedMessage)
}

void JoinGameFailedMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  joingamefailurereason_ = 1;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

JoinGameFailedMessage::~JoinGameFailedMessage() {
  // @@protoc_insertion_point(destructor:JoinGameFailedMessage)
  SharedDtor();
}

void JoinGameFailedMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void JoinGameFailedMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const JoinGameFailedMessage& JoinGameFailedMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

JoinGameFailedMessage* JoinGameFailedMessage::default_instance_ = NULL;

JoinGameFailedMessage* JoinGameFailedMessage::New() const {
  return new JoinGameFailedMessage;
}

void JoinGameFailedMessage::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    gameid_ = 0u;
    joingamefailurereason_ = 1;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool JoinGameFailedMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:JoinGameFailedMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_joinGameFailureReason;
        break;
      }

      // required .JoinGameFailedMessage.JoinGameFailureReason joinGameFailureReason = 2;
      case 2: {
        if (tag == 16) {
         parse_joinGameFailureReason:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::JoinGameFailedMessage_JoinGameFailureReason_IsValid(value)) {
            set_joingamefailurereason(static_cast< ::JoinGameFailedMessage_JoinGameFailureReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:JoinGameFailedMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:JoinGameFailedMessage)
  return false;
#undef DO_
}

void JoinGameFailedMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:JoinGameFailedMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required .JoinGameFailedMessage.JoinGameFailureReason joinGameFailureReason = 2;
  if (has_joingamefailurereason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->joingamefailurereason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:JoinGameFailedMessage)
}

int JoinGameFailedMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required .JoinGameFailedMessage.JoinGameFailureReason joinGameFailureReason = 2;
    if (has_joingamefailurereason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->joingamefailurereason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void JoinGameFailedMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const JoinGameFailedMessage*>(&from));
}

void JoinGameFailedMessage::MergeFrom(const JoinGameFailedMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_joingamefailurereason()) {
      set_joingamefailurereason(from.joingamefailurereason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void JoinGameFailedMessage::CopyFrom(const JoinGameFailedMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool JoinGameFailedMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void JoinGameFailedMessage::Swap(JoinGameFailedMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(joingamefailurereason_, other->joingamefailurereason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string JoinGameFailedMessage::GetTypeName() const {
  return "JoinGameFailedMessage";
}


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

#ifndef _MSC_VER
const int GamePlayerJoinedMessage::kGameIdFieldNumber;
const int GamePlayerJoinedMessage::kPlayerIdFieldNumber;
const int GamePlayerJoinedMessage::kIsGameAdminFieldNumber;
#endif  // !_MSC_VER

GamePlayerJoinedMessage::GamePlayerJoinedMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GamePlayerJoinedMessage)
}

void GamePlayerJoinedMessage::InitAsDefaultInstance() {
}

GamePlayerJoinedMessage::GamePlayerJoinedMessage(const GamePlayerJoinedMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GamePlayerJoinedMessage)
}

void GamePlayerJoinedMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  isgameadmin_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GamePlayerJoinedMessage::~GamePlayerJoinedMessage() {
  // @@protoc_insertion_point(destructor:GamePlayerJoinedMessage)
  SharedDtor();
}

void GamePlayerJoinedMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GamePlayerJoinedMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GamePlayerJoinedMessage& GamePlayerJoinedMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GamePlayerJoinedMessage* GamePlayerJoinedMessage::default_instance_ = NULL;

GamePlayerJoinedMessage* GamePlayerJoinedMessage::New() const {
  return new GamePlayerJoinedMessage;
}

void GamePlayerJoinedMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GamePlayerJoinedMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, isgameadmin_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GamePlayerJoinedMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GamePlayerJoinedMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_isGameAdmin;
        break;
      }

      // required bool isGameAdmin = 3;
      case 3: {
        if (tag == 24) {
         parse_isGameAdmin:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &isgameadmin_)));
          set_has_isgameadmin();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GamePlayerJoinedMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GamePlayerJoinedMessage)
  return false;
#undef DO_
}

void GamePlayerJoinedMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GamePlayerJoinedMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  // required bool isGameAdmin = 3;
  if (has_isgameadmin()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->isgameadmin(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GamePlayerJoinedMessage)
}

int GamePlayerJoinedMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required bool isGameAdmin = 3;
    if (has_isgameadmin()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GamePlayerJoinedMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GamePlayerJoinedMessage*>(&from));
}

void GamePlayerJoinedMessage::MergeFrom(const GamePlayerJoinedMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_isgameadmin()) {
      set_isgameadmin(from.isgameadmin());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GamePlayerJoinedMessage::CopyFrom(const GamePlayerJoinedMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GamePlayerJoinedMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void GamePlayerJoinedMessage::Swap(GamePlayerJoinedMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(isgameadmin_, other->isgameadmin_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GamePlayerJoinedMessage::GetTypeName() const {
  return "GamePlayerJoinedMessage";
}


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

bool GamePlayerLeftMessage_GamePlayerLeftReason_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const GamePlayerLeftMessage_GamePlayerLeftReason GamePlayerLeftMessage::leftOnRequest;
const GamePlayerLeftMessage_GamePlayerLeftReason GamePlayerLeftMessage::leftKicked;
const GamePlayerLeftMessage_GamePlayerLeftReason GamePlayerLeftMessage::leftError;
const GamePlayerLeftMessage_GamePlayerLeftReason GamePlayerLeftMessage::GamePlayerLeftReason_MIN;
const GamePlayerLeftMessage_GamePlayerLeftReason GamePlayerLeftMessage::GamePlayerLeftReason_MAX;
const int GamePlayerLeftMessage::GamePlayerLeftReason_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int GamePlayerLeftMessage::kGameIdFieldNumber;
const int GamePlayerLeftMessage::kPlayerIdFieldNumber;
const int GamePlayerLeftMessage::kGamePlayerLeftReasonFieldNumber;
#endif  // !_MSC_VER

GamePlayerLeftMessage::GamePlayerLeftMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GamePlayerLeftMessage)
}

void GamePlayerLeftMessage::InitAsDefaultInstance() {
}

GamePlayerLeftMessage::GamePlayerLeftMessage(const GamePlayerLeftMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GamePlayerLeftMessage)
}

void GamePlayerLeftMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  gameplayerleftreason_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GamePlayerLeftMessage::~GamePlayerLeftMessage() {
  // @@protoc_insertion_point(destructor:GamePlayerLeftMessage)
  SharedDtor();
}

void GamePlayerLeftMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GamePlayerLeftMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GamePlayerLeftMessage& GamePlayerLeftMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GamePlayerLeftMessage* GamePlayerLeftMessage::default_instance_ = NULL;

GamePlayerLeftMessage* GamePlayerLeftMessage::New() const {
  return new GamePlayerLeftMessage;
}

void GamePlayerLeftMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GamePlayerLeftMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, gameplayerleftreason_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GamePlayerLeftMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GamePlayerLeftMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_gamePlayerLeftReason;
        break;
      }

      // required .GamePlayerLeftMessage.GamePlayerLeftReason gamePlayerLeftReason = 3;
      case 3: {
        if (tag == 24) {
         parse_gamePlayerLeftReason:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::GamePlayerLeftMessage_GamePlayerLeftReason_IsValid(value)) {
            set_gameplayerleftreason(static_cast< ::GamePlayerLeftMessage_GamePlayerLeftReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GamePlayerLeftMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GamePlayerLeftMessage)
  return false;
#undef DO_
}

void GamePlayerLeftMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GamePlayerLeftMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  // required .GamePlayerLeftMessage.GamePlayerLeftReason gamePlayerLeftReason = 3;
  if (has_gameplayerleftreason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->gameplayerleftreason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GamePlayerLeftMessage)
}

int GamePlayerLeftMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required .GamePlayerLeftMessage.GamePlayerLeftReason gamePlayerLeftReason = 3;
    if (has_gameplayerleftreason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->gameplayerleftreason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GamePlayerLeftMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GamePlayerLeftMessage*>(&from));
}

void GamePlayerLeftMessage::MergeFrom(const GamePlayerLeftMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_gameplayerleftreason()) {
      set_gameplayerleftreason(from.gameplayerleftreason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GamePlayerLeftMessage::CopyFrom(const GamePlayerLeftMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GamePlayerLeftMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void GamePlayerLeftMessage::Swap(GamePlayerLeftMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(gameplayerleftreason_, other->gameplayerleftreason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GamePlayerLeftMessage::GetTypeName() const {
  return "GamePlayerLeftMessage";
}


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

#ifndef _MSC_VER
const int GameSpectatorJoinedMessage::kGameIdFieldNumber;
const int GameSpectatorJoinedMessage::kPlayerIdFieldNumber;
#endif  // !_MSC_VER

GameSpectatorJoinedMessage::GameSpectatorJoinedMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameSpectatorJoinedMessage)
}

void GameSpectatorJoinedMessage::InitAsDefaultInstance() {
}

GameSpectatorJoinedMessage::GameSpectatorJoinedMessage(const GameSpectatorJoinedMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameSpectatorJoinedMessage)
}

void GameSpectatorJoinedMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameSpectatorJoinedMessage::~GameSpectatorJoinedMessage() {
  // @@protoc_insertion_point(destructor:GameSpectatorJoinedMessage)
  SharedDtor();
}

void GameSpectatorJoinedMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameSpectatorJoinedMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameSpectatorJoinedMessage& GameSpectatorJoinedMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameSpectatorJoinedMessage* GameSpectatorJoinedMessage::default_instance_ = NULL;

GameSpectatorJoinedMessage* GameSpectatorJoinedMessage::New() const {
  return new GameSpectatorJoinedMessage;
}

void GameSpectatorJoinedMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameSpectatorJoinedMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameSpectatorJoinedMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameSpectatorJoinedMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameSpectatorJoinedMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameSpectatorJoinedMessage)
  return false;
#undef DO_
}

void GameSpectatorJoinedMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameSpectatorJoinedMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameSpectatorJoinedMessage)
}

int GameSpectatorJoinedMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameSpectatorJoinedMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameSpectatorJoinedMessage*>(&from));
}

void GameSpectatorJoinedMessage::MergeFrom(const GameSpectatorJoinedMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameSpectatorJoinedMessage::CopyFrom(const GameSpectatorJoinedMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameSpectatorJoinedMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void GameSpectatorJoinedMessage::Swap(GameSpectatorJoinedMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameSpectatorJoinedMessage::GetTypeName() const {
  return "GameSpectatorJoinedMessage";
}


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

#ifndef _MSC_VER
const int GameSpectatorLeftMessage::kGameIdFieldNumber;
const int GameSpectatorLeftMessage::kPlayerIdFieldNumber;
const int GameSpectatorLeftMessage::kGameSpectatorLeftReasonFieldNumber;
#endif  // !_MSC_VER

GameSpectatorLeftMessage::GameSpectatorLeftMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameSpectatorLeftMessage)
}

void GameSpectatorLeftMessage::InitAsDefaultInstance() {
}

GameSpectatorLeftMessage::GameSpectatorLeftMessage(const GameSpectatorLeftMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameSpectatorLeftMessage)
}

void GameSpectatorLeftMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  gamespectatorleftreason_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameSpectatorLeftMessage::~GameSpectatorLeftMessage() {
  // @@protoc_insertion_point(destructor:GameSpectatorLeftMessage)
  SharedDtor();
}

void GameSpectatorLeftMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameSpectatorLeftMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameSpectatorLeftMessage& GameSpectatorLeftMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameSpectatorLeftMessage* GameSpectatorLeftMessage::default_instance_ = NULL;

GameSpectatorLeftMessage* GameSpectatorLeftMessage::New() const {
  return new GameSpectatorLeftMessage;
}

void GameSpectatorLeftMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameSpectatorLeftMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, gamespectatorleftreason_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameSpectatorLeftMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameSpectatorLeftMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_gameSpectatorLeftReason;
        break;
      }

      // required .GamePlayerLeftMessage.GamePlayerLeftReason gameSpectatorLeftReason = 3;
      case 3: {
        if (tag == 24) {
         parse_gameSpectatorLeftReason:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::GamePlayerLeftMessage_GamePlayerLeftReason_IsValid(value)) {
            set_gamespectatorleftreason(static_cast< ::GamePlayerLeftMessage_GamePlayerLeftReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameSpectatorLeftMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameSpectatorLeftMessage)
  return false;
#undef DO_
}

void GameSpectatorLeftMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameSpectatorLeftMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  // required .GamePlayerLeftMessage.GamePlayerLeftReason gameSpectatorLeftReason = 3;
  if (has_gamespectatorleftreason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->gamespectatorleftreason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameSpectatorLeftMessage)
}

int GameSpectatorLeftMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required .GamePlayerLeftMessage.GamePlayerLeftReason gameSpectatorLeftReason = 3;
    if (has_gamespectatorleftreason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->gamespectatorleftreason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameSpectatorLeftMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameSpectatorLeftMessage*>(&from));
}

void GameSpectatorLeftMessage::MergeFrom(const GameSpectatorLeftMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_gamespectatorleftreason()) {
      set_gamespectatorleftreason(from.gamespectatorleftreason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameSpectatorLeftMessage::CopyFrom(const GameSpectatorLeftMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameSpectatorLeftMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void GameSpectatorLeftMessage::Swap(GameSpectatorLeftMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(gamespectatorleftreason_, other->gamespectatorleftreason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameSpectatorLeftMessage::GetTypeName() const {
  return "GameSpectatorLeftMessage";
}


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

#ifndef _MSC_VER
const int GameAdminChangedMessage::kGameIdFieldNumber;
const int GameAdminChangedMessage::kNewAdminPlayerIdFieldNumber;
#endif  // !_MSC_VER

GameAdminChangedMessage::GameAdminChangedMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameAdminChangedMessage)
}

void GameAdminChangedMessage::InitAsDefaultInstance() {
}

GameAdminChangedMessage::GameAdminChangedMessage(const GameAdminChangedMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameAdminChangedMessage)
}

void GameAdminChangedMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  newadminplayerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameAdminChangedMessage::~GameAdminChangedMessage() {
  // @@protoc_insertion_point(destructor:GameAdminChangedMessage)
  SharedDtor();
}

void GameAdminChangedMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameAdminChangedMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameAdminChangedMessage& GameAdminChangedMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameAdminChangedMessage* GameAdminChangedMessage::default_instance_ = NULL;

GameAdminChangedMessage* GameAdminChangedMessage::New() const {
  return new GameAdminChangedMessage;
}

void GameAdminChangedMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameAdminChangedMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, newadminplayerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameAdminChangedMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameAdminChangedMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_newAdminPlayerId;
        break;
      }

      // required uint32 newAdminPlayerId = 2;
      case 2: {
        if (tag == 16) {
         parse_newAdminPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &newadminplayerid_)));
          set_has_newadminplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameAdminChangedMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameAdminChangedMessage)
  return false;
#undef DO_
}

void GameAdminChangedMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameAdminChangedMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 newAdminPlayerId = 2;
  if (has_newadminplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->newadminplayerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameAdminChangedMessage)
}

int GameAdminChangedMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 newAdminPlayerId = 2;
    if (has_newadminplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->newadminplayerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameAdminChangedMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameAdminChangedMessage*>(&from));
}

void GameAdminChangedMessage::MergeFrom(const GameAdminChangedMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_newadminplayerid()) {
      set_newadminplayerid(from.newadminplayerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameAdminChangedMessage::CopyFrom(const GameAdminChangedMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameAdminChangedMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void GameAdminChangedMessage::Swap(GameAdminChangedMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(newadminplayerid_, other->newadminplayerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameAdminChangedMessage::GetTypeName() const {
  return "GameAdminChangedMessage";
}


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

bool RemovedFromGameMessage_RemovedFromGameReason_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const RemovedFromGameMessage_RemovedFromGameReason RemovedFromGameMessage::removedOnRequest;
const RemovedFromGameMessage_RemovedFromGameReason RemovedFromGameMessage::kickedFromGame;
const RemovedFromGameMessage_RemovedFromGameReason RemovedFromGameMessage::gameIsFull;
const RemovedFromGameMessage_RemovedFromGameReason RemovedFromGameMessage::gameIsRunning;
const RemovedFromGameMessage_RemovedFromGameReason RemovedFromGameMessage::gameTimeout;
const RemovedFromGameMessage_RemovedFromGameReason RemovedFromGameMessage::removedStartFailed;
const RemovedFromGameMessage_RemovedFromGameReason RemovedFromGameMessage::gameClosed;
const RemovedFromGameMessage_RemovedFromGameReason RemovedFromGameMessage::RemovedFromGameReason_MIN;
const RemovedFromGameMessage_RemovedFromGameReason RemovedFromGameMessage::RemovedFromGameReason_MAX;
const int RemovedFromGameMessage::RemovedFromGameReason_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int RemovedFromGameMessage::kGameIdFieldNumber;
const int RemovedFromGameMessage::kRemovedFromGameReasonFieldNumber;
#endif  // !_MSC_VER

RemovedFromGameMessage::RemovedFromGameMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:RemovedFromGameMessage)
}

void RemovedFromGameMessage::InitAsDefaultInstance() {
}

RemovedFromGameMessage::RemovedFromGameMessage(const RemovedFromGameMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:RemovedFromGameMessage)
}

void RemovedFromGameMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  removedfromgamereason_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RemovedFromGameMessage::~RemovedFromGameMessage() {
  // @@protoc_insertion_point(destructor:RemovedFromGameMessage)
  SharedDtor();
}

void RemovedFromGameMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void RemovedFromGameMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RemovedFromGameMessage& RemovedFromGameMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

RemovedFromGameMessage* RemovedFromGameMessage::default_instance_ = NULL;

RemovedFromGameMessage* RemovedFromGameMessage::New() const {
  return new RemovedFromGameMessage;
}

void RemovedFromGameMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<RemovedFromGameMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, removedfromgamereason_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool RemovedFromGameMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:RemovedFromGameMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_removedFromGameReason;
        break;
      }

      // required .RemovedFromGameMessage.RemovedFromGameReason removedFromGameReason = 2;
      case 2: {
        if (tag == 16) {
         parse_removedFromGameReason:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::RemovedFromGameMessage_RemovedFromGameReason_IsValid(value)) {
            set_removedfromgamereason(static_cast< ::RemovedFromGameMessage_RemovedFromGameReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:RemovedFromGameMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:RemovedFromGameMessage)
  return false;
#undef DO_
}

void RemovedFromGameMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:RemovedFromGameMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required .RemovedFromGameMessage.RemovedFromGameReason removedFromGameReason = 2;
  if (has_removedfromgamereason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->removedfromgamereason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:RemovedFromGameMessage)
}

int RemovedFromGameMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required .RemovedFromGameMessage.RemovedFromGameReason removedFromGameReason = 2;
    if (has_removedfromgamereason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->removedfromgamereason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RemovedFromGameMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RemovedFromGameMessage*>(&from));
}

void RemovedFromGameMessage::MergeFrom(const RemovedFromGameMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_removedfromgamereason()) {
      set_removedfromgamereason(from.removedfromgamereason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void RemovedFromGameMessage::CopyFrom(const RemovedFromGameMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RemovedFromGameMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void RemovedFromGameMessage::Swap(RemovedFromGameMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(removedfromgamereason_, other->removedfromgamereason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string RemovedFromGameMessage::GetTypeName() const {
  return "RemovedFromGameMessage";
}


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

#ifndef _MSC_VER
const int KickPlayerRequestMessage::kGameIdFieldNumber;
const int KickPlayerRequestMessage::kPlayerIdFieldNumber;
#endif  // !_MSC_VER

KickPlayerRequestMessage::KickPlayerRequestMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:KickPlayerRequestMessage)
}

void KickPlayerRequestMessage::InitAsDefaultInstance() {
}

KickPlayerRequestMessage::KickPlayerRequestMessage(const KickPlayerRequestMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:KickPlayerRequestMessage)
}

void KickPlayerRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

KickPlayerRequestMessage::~KickPlayerRequestMessage() {
  // @@protoc_insertion_point(destructor:KickPlayerRequestMessage)
  SharedDtor();
}

void KickPlayerRequestMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void KickPlayerRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const KickPlayerRequestMessage& KickPlayerRequestMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

KickPlayerRequestMessage* KickPlayerRequestMessage::default_instance_ = NULL;

KickPlayerRequestMessage* KickPlayerRequestMessage::New() const {
  return new KickPlayerRequestMessage;
}

void KickPlayerRequestMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<KickPlayerRequestMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool KickPlayerRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:KickPlayerRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:KickPlayerRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:KickPlayerRequestMessage)
  return false;
#undef DO_
}

void KickPlayerRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:KickPlayerRequestMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:KickPlayerRequestMessage)
}

int KickPlayerRequestMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void KickPlayerRequestMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const KickPlayerRequestMessage*>(&from));
}

void KickPlayerRequestMessage::MergeFrom(const KickPlayerRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void KickPlayerRequestMessage::CopyFrom(const KickPlayerRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool KickPlayerRequestMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void KickPlayerRequestMessage::Swap(KickPlayerRequestMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string KickPlayerRequestMessage::GetTypeName() const {
  return "KickPlayerRequestMessage";
}


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

#ifndef _MSC_VER
const int LeaveGameRequestMessage::kGameIdFieldNumber;
#endif  // !_MSC_VER

LeaveGameRequestMessage::LeaveGameRequestMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:LeaveGameRequestMessage)
}

void LeaveGameRequestMessage::InitAsDefaultInstance() {
}

LeaveGameRequestMessage::LeaveGameRequestMessage(const LeaveGameRequestMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:LeaveGameRequestMessage)
}

void LeaveGameRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LeaveGameRequestMessage::~LeaveGameRequestMessage() {
  // @@protoc_insertion_point(destructor:LeaveGameRequestMessage)
  SharedDtor();
}

void LeaveGameRequestMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void LeaveGameRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const LeaveGameRequestMessage& LeaveGameRequestMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

LeaveGameRequestMessage* LeaveGameRequestMessage::default_instance_ = NULL;

LeaveGameRequestMessage* LeaveGameRequestMessage::New() const {
  return new LeaveGameRequestMessage;
}

void LeaveGameRequestMessage::Clear() {
  gameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool LeaveGameRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:LeaveGameRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:LeaveGameRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:LeaveGameRequestMessage)
  return false;
#undef DO_
}

void LeaveGameRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:LeaveGameRequestMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:LeaveGameRequestMessage)
}

int LeaveGameRequestMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LeaveGameRequestMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const LeaveGameRequestMessage*>(&from));
}

void LeaveGameRequestMessage::MergeFrom(const LeaveGameRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void LeaveGameRequestMessage::CopyFrom(const LeaveGameRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LeaveGameRequestMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void LeaveGameRequestMessage::Swap(LeaveGameRequestMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string LeaveGameRequestMessage::GetTypeName() const {
  return "LeaveGameRequestMessage";
}


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

#ifndef _MSC_VER
const int InvitePlayerToGameMessage::kGameIdFieldNumber;
const int InvitePlayerToGameMessage::kPlayerIdFieldNumber;
#endif  // !_MSC_VER

InvitePlayerToGameMessage::InvitePlayerToGameMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:InvitePlayerToGameMessage)
}

void InvitePlayerToGameMessage::InitAsDefaultInstance() {
}

InvitePlayerToGameMessage::InvitePlayerToGameMessage(const InvitePlayerToGameMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:InvitePlayerToGameMessage)
}

void InvitePlayerToGameMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

InvitePlayerToGameMessage::~InvitePlayerToGameMessage() {
  // @@protoc_insertion_point(destructor:InvitePlayerToGameMessage)
  SharedDtor();
}

void InvitePlayerToGameMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void InvitePlayerToGameMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const InvitePlayerToGameMessage& InvitePlayerToGameMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

InvitePlayerToGameMessage* InvitePlayerToGameMessage::default_instance_ = NULL;

InvitePlayerToGameMessage* InvitePlayerToGameMessage::New() const {
  return new InvitePlayerToGameMessage;
}

void InvitePlayerToGameMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<InvitePlayerToGameMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool InvitePlayerToGameMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:InvitePlayerToGameMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:InvitePlayerToGameMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:InvitePlayerToGameMessage)
  return false;
#undef DO_
}

void InvitePlayerToGameMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:InvitePlayerToGameMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:InvitePlayerToGameMessage)
}

int InvitePlayerToGameMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void InvitePlayerToGameMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const InvitePlayerToGameMessage*>(&from));
}

void InvitePlayerToGameMessage::MergeFrom(const InvitePlayerToGameMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void InvitePlayerToGameMessage::CopyFrom(const InvitePlayerToGameMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool InvitePlayerToGameMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void InvitePlayerToGameMessage::Swap(InvitePlayerToGameMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string InvitePlayerToGameMessage::GetTypeName() const {
  return "InvitePlayerToGameMessage";
}


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

#ifndef _MSC_VER
const int InviteNotifyMessage::kGameIdFieldNumber;
const int InviteNotifyMessage::kPlayerIdWhoFieldNumber;
const int InviteNotifyMessage::kPlayerIdByWhomFieldNumber;
#endif  // !_MSC_VER

InviteNotifyMessage::InviteNotifyMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:InviteNotifyMessage)
}

void InviteNotifyMessage::InitAsDefaultInstance() {
}

InviteNotifyMessage::InviteNotifyMessage(const InviteNotifyMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:InviteNotifyMessage)
}

void InviteNotifyMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playeridwho_ = 0u;
  playeridbywhom_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

InviteNotifyMessage::~InviteNotifyMessage() {
  // @@protoc_insertion_point(destructor:InviteNotifyMessage)
  SharedDtor();
}

void InviteNotifyMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void InviteNotifyMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const InviteNotifyMessage& InviteNotifyMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

InviteNotifyMessage* InviteNotifyMessage::default_instance_ = NULL;

InviteNotifyMessage* InviteNotifyMessage::New() const {
  return new InviteNotifyMessage;
}

void InviteNotifyMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<InviteNotifyMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playeridbywhom_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool InviteNotifyMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:InviteNotifyMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerIdWho;
        break;
      }

      // required uint32 playerIdWho = 2;
      case 2: {
        if (tag == 16) {
         parse_playerIdWho:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playeridwho_)));
          set_has_playeridwho();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_playerIdByWhom;
        break;
      }

      // required uint32 playerIdByWhom = 3;
      case 3: {
        if (tag == 24) {
         parse_playerIdByWhom:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playeridbywhom_)));
          set_has_playeridbywhom();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:InviteNotifyMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:InviteNotifyMessage)
  return false;
#undef DO_
}

void InviteNotifyMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:InviteNotifyMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerIdWho = 2;
  if (has_playeridwho()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playeridwho(), output);
  }

  // required uint32 playerIdByWhom = 3;
  if (has_playeridbywhom()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->playeridbywhom(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:InviteNotifyMessage)
}

int InviteNotifyMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerIdWho = 2;
    if (has_playeridwho()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playeridwho());
    }

    // required uint32 playerIdByWhom = 3;
    if (has_playeridbywhom()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playeridbywhom());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void InviteNotifyMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const InviteNotifyMessage*>(&from));
}

void InviteNotifyMessage::MergeFrom(const InviteNotifyMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playeridwho()) {
      set_playeridwho(from.playeridwho());
    }
    if (from.has_playeridbywhom()) {
      set_playeridbywhom(from.playeridbywhom());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void InviteNotifyMessage::CopyFrom(const InviteNotifyMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool InviteNotifyMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void InviteNotifyMessage::Swap(InviteNotifyMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playeridwho_, other->playeridwho_);
    std::swap(playeridbywhom_, other->playeridbywhom_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string InviteNotifyMessage::GetTypeName() const {
  return "InviteNotifyMessage";
}


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

bool RejectGameInvitationMessage_RejectGameInvReason_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const RejectGameInvitationMessage_RejectGameInvReason RejectGameInvitationMessage::rejectReasonNo;
const RejectGameInvitationMessage_RejectGameInvReason RejectGameInvitationMessage::rejectReasonBusy;
const RejectGameInvitationMessage_RejectGameInvReason RejectGameInvitationMessage::RejectGameInvReason_MIN;
const RejectGameInvitationMessage_RejectGameInvReason RejectGameInvitationMessage::RejectGameInvReason_MAX;
const int RejectGameInvitationMessage::RejectGameInvReason_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int RejectGameInvitationMessage::kGameIdFieldNumber;
const int RejectGameInvitationMessage::kMyRejectReasonFieldNumber;
#endif  // !_MSC_VER

RejectGameInvitationMessage::RejectGameInvitationMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:RejectGameInvitationMessage)
}

void RejectGameInvitationMessage::InitAsDefaultInstance() {
}

RejectGameInvitationMessage::RejectGameInvitationMessage(const RejectGameInvitationMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:RejectGameInvitationMessage)
}

void RejectGameInvitationMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  myrejectreason_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RejectGameInvitationMessage::~RejectGameInvitationMessage() {
  // @@protoc_insertion_point(destructor:RejectGameInvitationMessage)
  SharedDtor();
}

void RejectGameInvitationMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void RejectGameInvitationMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RejectGameInvitationMessage& RejectGameInvitationMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

RejectGameInvitationMessage* RejectGameInvitationMessage::default_instance_ = NULL;

RejectGameInvitationMessage* RejectGameInvitationMessage::New() const {
  return new RejectGameInvitationMessage;
}

void RejectGameInvitationMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<RejectGameInvitationMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, myrejectreason_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool RejectGameInvitationMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:RejectGameInvitationMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_myRejectReason;
        break;
      }

      // required .RejectGameInvitationMessage.RejectGameInvReason myRejectReason = 2;
      case 2: {
        if (tag == 16) {
         parse_myRejectReason:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::RejectGameInvitationMessage_RejectGameInvReason_IsValid(value)) {
            set_myrejectreason(static_cast< ::RejectGameInvitationMessage_RejectGameInvReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:RejectGameInvitationMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:RejectGameInvitationMessage)
  return false;
#undef DO_
}

void RejectGameInvitationMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:RejectGameInvitationMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required .RejectGameInvitationMessage.RejectGameInvReason myRejectReason = 2;
  if (has_myrejectreason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->myrejectreason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:RejectGameInvitationMessage)
}

int RejectGameInvitationMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required .RejectGameInvitationMessage.RejectGameInvReason myRejectReason = 2;
    if (has_myrejectreason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->myrejectreason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RejectGameInvitationMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RejectGameInvitationMessage*>(&from));
}

void RejectGameInvitationMessage::MergeFrom(const RejectGameInvitationMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_myrejectreason()) {
      set_myrejectreason(from.myrejectreason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void RejectGameInvitationMessage::CopyFrom(const RejectGameInvitationMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RejectGameInvitationMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void RejectGameInvitationMessage::Swap(RejectGameInvitationMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(myrejectreason_, other->myrejectreason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string RejectGameInvitationMessage::GetTypeName() const {
  return "RejectGameInvitationMessage";
}


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

#ifndef _MSC_VER
const int RejectInvNotifyMessage::kGameIdFieldNumber;
const int RejectInvNotifyMessage::kPlayerIdFieldNumber;
const int RejectInvNotifyMessage::kPlayerRejectReasonFieldNumber;
#endif  // !_MSC_VER

RejectInvNotifyMessage::RejectInvNotifyMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:RejectInvNotifyMessage)
}

void RejectInvNotifyMessage::InitAsDefaultInstance() {
}

RejectInvNotifyMessage::RejectInvNotifyMessage(const RejectInvNotifyMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:RejectInvNotifyMessage)
}

void RejectInvNotifyMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  playerrejectreason_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RejectInvNotifyMessage::~RejectInvNotifyMessage() {
  // @@protoc_insertion_point(destructor:RejectInvNotifyMessage)
  SharedDtor();
}

void RejectInvNotifyMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void RejectInvNotifyMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RejectInvNotifyMessage& RejectInvNotifyMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

RejectInvNotifyMessage* RejectInvNotifyMessage::default_instance_ = NULL;

RejectInvNotifyMessage* RejectInvNotifyMessage::New() const {
  return new RejectInvNotifyMessage;
}

void RejectInvNotifyMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<RejectInvNotifyMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playerrejectreason_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool RejectInvNotifyMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:RejectInvNotifyMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_playerRejectReason;
        break;
      }

      // required .RejectGameInvitationMessage.RejectGameInvReason playerRejectReason = 3;
      case 3: {
        if (tag == 24) {
         parse_playerRejectReason:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::RejectGameInvitationMessage_RejectGameInvReason_IsValid(value)) {
            set_playerrejectreason(static_cast< ::RejectGameInvitationMessage_RejectGameInvReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:RejectInvNotifyMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:RejectInvNotifyMessage)
  return false;
#undef DO_
}

void RejectInvNotifyMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:RejectInvNotifyMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  // required .RejectGameInvitationMessage.RejectGameInvReason playerRejectReason = 3;
  if (has_playerrejectreason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->playerrejectreason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:RejectInvNotifyMessage)
}

int RejectInvNotifyMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required .RejectGameInvitationMessage.RejectGameInvReason playerRejectReason = 3;
    if (has_playerrejectreason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->playerrejectreason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RejectInvNotifyMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RejectInvNotifyMessage*>(&from));
}

void RejectInvNotifyMessage::MergeFrom(const RejectInvNotifyMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_playerrejectreason()) {
      set_playerrejectreason(from.playerrejectreason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void RejectInvNotifyMessage::CopyFrom(const RejectInvNotifyMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RejectInvNotifyMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void RejectInvNotifyMessage::Swap(RejectInvNotifyMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(playerrejectreason_, other->playerrejectreason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string RejectInvNotifyMessage::GetTypeName() const {
  return "RejectInvNotifyMessage";
}


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

bool StartEventMessage_StartEventType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const StartEventMessage_StartEventType StartEventMessage::startEvent;
const StartEventMessage_StartEventType StartEventMessage::rejoinEvent;
const StartEventMessage_StartEventType StartEventMessage::StartEventType_MIN;
const StartEventMessage_StartEventType StartEventMessage::StartEventType_MAX;
const int StartEventMessage::StartEventType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int StartEventMessage::kGameIdFieldNumber;
const int StartEventMessage::kStartEventTypeFieldNumber;
const int StartEventMessage::kFillWithComputerPlayersFieldNumber;
#endif  // !_MSC_VER

StartEventMessage::StartEventMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:StartEventMessage)
}

void StartEventMessage::InitAsDefaultInstance() {
}

StartEventMessage::StartEventMessage(const StartEventMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:StartEventMessage)
}

void StartEventMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  starteventtype_ = 0;
  fillwithcomputerplayers_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StartEventMessage::~StartEventMessage() {
  // @@protoc_insertion_point(destructor:StartEventMessage)
  SharedDtor();
}

void StartEventMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void StartEventMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const StartEventMessage& StartEventMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

StartEventMessage* StartEventMessage::default_instance_ = NULL;

StartEventMessage* StartEventMessage::New() const {
  return new StartEventMessage;
}

void StartEventMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<StartEventMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, fillwithcomputerplayers_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool StartEventMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:StartEventMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_startEventType;
        break;
      }

      // required .StartEventMessage.StartEventType startEventType = 2;
      case 2: {
        if (tag == 16) {
         parse_startEventType:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::StartEventMessage_StartEventType_IsValid(value)) {
            set_starteventtype(static_cast< ::StartEventMessage_StartEventType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_fillWithComputerPlayers;
        break;
      }

      // optional bool fillWithComputerPlayers = 3;
      case 3: {
        if (tag == 24) {
         parse_fillWithComputerPlayers:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &fillwithcomputerplayers_)));
          set_has_fillwithcomputerplayers();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:StartEventMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:StartEventMessage)
  return false;
#undef DO_
}

void StartEventMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:StartEventMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required .StartEventMessage.StartEventType startEventType = 2;
  if (has_starteventtype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->starteventtype(), output);
  }

  // optional bool fillWithComputerPlayers = 3;
  if (has_fillwithcomputerplayers()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->fillwithcomputerplayers(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:StartEventMessage)
}

int StartEventMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required .StartEventMessage.StartEventType startEventType = 2;
    if (has_starteventtype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->starteventtype());
    }

    // optional bool fillWithComputerPlayers = 3;
    if (has_fillwithcomputerplayers()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StartEventMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const StartEventMessage*>(&from));
}

void StartEventMessage::MergeFrom(const StartEventMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_starteventtype()) {
      set_starteventtype(from.starteventtype());
    }
    if (from.has_fillwithcomputerplayers()) {
      set_fillwithcomputerplayers(from.fillwithcomputerplayers());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void StartEventMessage::CopyFrom(const StartEventMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StartEventMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void StartEventMessage::Swap(StartEventMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(starteventtype_, other->starteventtype_);
    std::swap(fillwithcomputerplayers_, other->fillwithcomputerplayers_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string StartEventMessage::GetTypeName() const {
  return "StartEventMessage";
}


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

#ifndef _MSC_VER
const int StartEventAckMessage::kGameIdFieldNumber;
#endif  // !_MSC_VER

StartEventAckMessage::StartEventAckMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:StartEventAckMessage)
}

void StartEventAckMessage::InitAsDefaultInstance() {
}

StartEventAckMessage::StartEventAckMessage(const StartEventAckMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:StartEventAckMessage)
}

void StartEventAckMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StartEventAckMessage::~StartEventAckMessage() {
  // @@protoc_insertion_point(destructor:StartEventAckMessage)
  SharedDtor();
}

void StartEventAckMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void StartEventAckMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const StartEventAckMessage& StartEventAckMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

StartEventAckMessage* StartEventAckMessage::default_instance_ = NULL;

StartEventAckMessage* StartEventAckMessage::New() const {
  return new StartEventAckMessage;
}

void StartEventAckMessage::Clear() {
  gameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool StartEventAckMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:StartEventAckMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:StartEventAckMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:StartEventAckMessage)
  return false;
#undef DO_
}

void StartEventAckMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:StartEventAckMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:StartEventAckMessage)
}

int StartEventAckMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StartEventAckMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const StartEventAckMessage*>(&from));
}

void StartEventAckMessage::MergeFrom(const StartEventAckMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void StartEventAckMessage::CopyFrom(const StartEventAckMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StartEventAckMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void StartEventAckMessage::Swap(StartEventAckMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string StartEventAckMessage::GetTypeName() const {
  return "StartEventAckMessage";
}


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

#ifndef _MSC_VER
const int GameStartInitialMessage::kGameIdFieldNumber;
const int GameStartInitialMessage::kStartDealerPlayerIdFieldNumber;
const int GameStartInitialMessage::kPlayerSeatsFieldNumber;
#endif  // !_MSC_VER

GameStartInitialMessage::GameStartInitialMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameStartInitialMessage)
}

void GameStartInitialMessage::InitAsDefaultInstance() {
}

GameStartInitialMessage::GameStartInitialMessage(const GameStartInitialMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameStartInitialMessage)
}

void GameStartInitialMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  startdealerplayerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameStartInitialMessage::~GameStartInitialMessage() {
  // @@protoc_insertion_point(destructor:GameStartInitialMessage)
  SharedDtor();
}

void GameStartInitialMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameStartInitialMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameStartInitialMessage& GameStartInitialMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameStartInitialMessage* GameStartInitialMessage::default_instance_ = NULL;

GameStartInitialMessage* GameStartInitialMessage::New() const {
  return new GameStartInitialMessage;
}

void GameStartInitialMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameStartInitialMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, startdealerplayerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  playerseats_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameStartInitialMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameStartInitialMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_startDealerPlayerId;
        break;
      }

      // required uint32 startDealerPlayerId = 2;
      case 2: {
        if (tag == 16) {
         parse_startDealerPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &startdealerplayerid_)));
          set_has_startdealerplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_playerSeats;
        break;
      }

      // repeated uint32 playerSeats = 3 [packed = true];
      case 3: {
        if (tag == 26) {
         parse_playerSeats:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_playerseats())));
        } else if (tag == 24) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 1, 26, input, this->mutable_playerseats())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameStartInitialMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameStartInitialMessage)
  return false;
#undef DO_
}

void GameStartInitialMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameStartInitialMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 startDealerPlayerId = 2;
  if (has_startdealerplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->startdealerplayerid(), output);
  }

  // repeated uint32 playerSeats = 3 [packed = true];
  if (this->playerseats_size() > 0) {
    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
    output->WriteVarint32(_playerseats_cached_byte_size_);
  }
  for (int i = 0; i < this->playerseats_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
      this->playerseats(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameStartInitialMessage)
}

int GameStartInitialMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 startDealerPlayerId = 2;
    if (has_startdealerplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->startdealerplayerid());
    }

  }
  // repeated uint32 playerSeats = 3 [packed = true];
  {
    int data_size = 0;
    for (int i = 0; i < this->playerseats_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt32Size(this->playerseats(i));
    }
    if (data_size > 0) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _playerseats_cached_byte_size_ = data_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    total_size += data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameStartInitialMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameStartInitialMessage*>(&from));
}

void GameStartInitialMessage::MergeFrom(const GameStartInitialMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  playerseats_.MergeFrom(from.playerseats_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_startdealerplayerid()) {
      set_startdealerplayerid(from.startdealerplayerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameStartInitialMessage::CopyFrom(const GameStartInitialMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameStartInitialMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void GameStartInitialMessage::Swap(GameStartInitialMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(startdealerplayerid_, other->startdealerplayerid_);
    playerseats_.Swap(&other->playerseats_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameStartInitialMessage::GetTypeName() const {
  return "GameStartInitialMessage";
}


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

#ifndef _MSC_VER
const int GameStartRejoinMessage_RejoinPlayerData::kPlayerIdFieldNumber;
const int GameStartRejoinMessage_RejoinPlayerData::kPlayerMoneyFieldNumber;
#endif  // !_MSC_VER

GameStartRejoinMessage_RejoinPlayerData::GameStartRejoinMessage_RejoinPlayerData()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameStartRejoinMessage.RejoinPlayerData)
}

void GameStartRejoinMessage_RejoinPlayerData::InitAsDefaultInstance() {
}

GameStartRejoinMessage_RejoinPlayerData::GameStartRejoinMessage_RejoinPlayerData(const GameStartRejoinMessage_RejoinPlayerData& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameStartRejoinMessage.RejoinPlayerData)
}

void GameStartRejoinMessage_RejoinPlayerData::SharedCtor() {
  _cached_size_ = 0;
  playerid_ = 0u;
  playermoney_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameStartRejoinMessage_RejoinPlayerData::~GameStartRejoinMessage_RejoinPlayerData() {
  // @@protoc_insertion_point(destructor:GameStartRejoinMessage.RejoinPlayerData)
  SharedDtor();
}

void GameStartRejoinMessage_RejoinPlayerData::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameStartRejoinMessage_RejoinPlayerData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameStartRejoinMessage_RejoinPlayerData& GameStartRejoinMessage_RejoinPlayerData::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameStartRejoinMessage_RejoinPlayerData* GameStartRejoinMessage_RejoinPlayerData::default_instance_ = NULL;

GameStartRejoinMessage_RejoinPlayerData* GameStartRejoinMessage_RejoinPlayerData::New() const {
  return new GameStartRejoinMessage_RejoinPlayerData;
}

void GameStartRejoinMessage_RejoinPlayerData::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameStartRejoinMessage_RejoinPlayerData*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(playerid_, playermoney_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameStartRejoinMessage_RejoinPlayerData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameStartRejoinMessage.RejoinPlayerData)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 playerId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerMoney;
        break;
      }

      // required uint32 playerMoney = 2;
      case 2: {
        if (tag == 16) {
         parse_playerMoney:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playermoney_)));
          set_has_playermoney();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameStartRejoinMessage.RejoinPlayerData)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameStartRejoinMessage.RejoinPlayerData)
  return false;
#undef DO_
}

void GameStartRejoinMessage_RejoinPlayerData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameStartRejoinMessage.RejoinPlayerData)
  // required uint32 playerId = 1;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output);
  }

  // required uint32 playerMoney = 2;
  if (has_playermoney()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playermoney(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameStartRejoinMessage.RejoinPlayerData)
}

int GameStartRejoinMessage_RejoinPlayerData::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 playerId = 1;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required uint32 playerMoney = 2;
    if (has_playermoney()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playermoney());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameStartRejoinMessage_RejoinPlayerData::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameStartRejoinMessage_RejoinPlayerData*>(&from));
}

void GameStartRejoinMessage_RejoinPlayerData::MergeFrom(const GameStartRejoinMessage_RejoinPlayerData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_playermoney()) {
      set_playermoney(from.playermoney());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameStartRejoinMessage_RejoinPlayerData::CopyFrom(const GameStartRejoinMessage_RejoinPlayerData& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameStartRejoinMessage_RejoinPlayerData::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void GameStartRejoinMessage_RejoinPlayerData::Swap(GameStartRejoinMessage_RejoinPlayerData* other) {
  if (other != this) {
    std::swap(playerid_, other->playerid_);
    std::swap(playermoney_, other->playermoney_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameStartRejoinMessage_RejoinPlayerData::GetTypeName() const {
  return "GameStartRejoinMessage.RejoinPlayerData";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int GameStartRejoinMessage::kGameIdFieldNumber;
const int GameStartRejoinMessage::kStartDealerPlayerIdFieldNumber;
const int GameStartRejoinMessage::kHandNumFieldNumber;
const int GameStartRejoinMessage::kRejoinPlayerDataFieldNumber;
#endif  // !_MSC_VER

GameStartRejoinMessage::GameStartRejoinMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:GameStartRejoinMessage)
}

void GameStartRejoinMessage::InitAsDefaultInstance() {
}

GameStartRejoinMessage::GameStartRejoinMessage(const GameStartRejoinMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:GameStartRejoinMessage)
}

void GameStartRejoinMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  startdealerplayerid_ = 0u;
  handnum_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

GameStartRejoinMessage::~GameStartRejoinMessage() {
  // @@protoc_insertion_point(destructor:GameStartRejoinMessage)
  SharedDtor();
}

void GameStartRejoinMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void GameStartRejoinMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GameStartRejoinMessage& GameStartRejoinMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

GameStartRejoinMessage* GameStartRejoinMessage::default_instance_ = NULL;

GameStartRejoinMessage* GameStartRejoinMessage::New() const {
  return new GameStartRejoinMessage;
}

void GameStartRejoinMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<GameStartRejoinMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 7) {
    ZR_(gameid_, startdealerplayerid_);
    handnum_ = 0u;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  rejoinplayerdata_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool GameStartRejoinMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:GameStartRejoinMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_startDealerPlayerId;
        break;
      }

      // required uint32 startDealerPlayerId = 2;
      case 2: {
        if (tag == 16) {
         parse_startDealerPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &startdealerplayerid_)));
          set_has_startdealerplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_handNum;
        break;
      }

      // required uint32 handNum = 3;
      case 3: {
        if (tag == 24) {
         parse_handNum:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &handnum_)));
          set_has_handnum();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_rejoinPlayerData;
        break;
      }

      // repeated .GameStartRejoinMessage.RejoinPlayerData rejoinPlayerData = 4;
      case 4: {
        if (tag == 34) {
         parse_rejoinPlayerData:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_rejoinplayerdata()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_rejoinPlayerData;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:GameStartRejoinMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:GameStartRejoinMessage)
  return false;
#undef DO_
}

void GameStartRejoinMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:GameStartRejoinMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 startDealerPlayerId = 2;
  if (has_startdealerplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->startdealerplayerid(), output);
  }

  // required uint32 handNum = 3;
  if (has_handnum()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->handnum(), output);
  }

  // repeated .GameStartRejoinMessage.RejoinPlayerData rejoinPlayerData = 4;
  for (int i = 0; i < this->rejoinplayerdata_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, this->rejoinplayerdata(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:GameStartRejoinMessage)
}

int GameStartRejoinMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 startDealerPlayerId = 2;
    if (has_startdealerplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->startdealerplayerid());
    }

    // required uint32 handNum = 3;
    if (has_handnum()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->handnum());
    }

  }
  // repeated .GameStartRejoinMessage.RejoinPlayerData rejoinPlayerData = 4;
  total_size += 1 * this->rejoinplayerdata_size();
  for (int i = 0; i < this->rejoinplayerdata_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->rejoinplayerdata(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GameStartRejoinMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GameStartRejoinMessage*>(&from));
}

void GameStartRejoinMessage::MergeFrom(const GameStartRejoinMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  rejoinplayerdata_.MergeFrom(from.rejoinplayerdata_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_startdealerplayerid()) {
      set_startdealerplayerid(from.startdealerplayerid());
    }
    if (from.has_handnum()) {
      set_handnum(from.handnum());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void GameStartRejoinMessage::CopyFrom(const GameStartRejoinMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GameStartRejoinMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->rejoinplayerdata())) return false;
  return true;
}

void GameStartRejoinMessage::Swap(GameStartRejoinMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(startdealerplayerid_, other->startdealerplayerid_);
    std::swap(handnum_, other->handnum_);
    rejoinplayerdata_.Swap(&other->rejoinplayerdata_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string GameStartRejoinMessage::GetTypeName() const {
  return "GameStartRejoinMessage";
}


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

#ifndef _MSC_VER
const int HandStartMessage_PlainCards::kPlainCard1FieldNumber;
const int HandStartMessage_PlainCards::kPlainCard2FieldNumber;
#endif  // !_MSC_VER

HandStartMessage_PlainCards::HandStartMessage_PlainCards()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:HandStartMessage.PlainCards)
}

void HandStartMessage_PlainCards::InitAsDefaultInstance() {
}

HandStartMessage_PlainCards::HandStartMessage_PlainCards(const HandStartMessage_PlainCards& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:HandStartMessage.PlainCards)
}

void HandStartMessage_PlainCards::SharedCtor() {
  _cached_size_ = 0;
  plaincard1_ = 0u;
  plaincard2_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

HandStartMessage_PlainCards::~HandStartMessage_PlainCards() {
  // @@protoc_insertion_point(destructor:HandStartMessage.PlainCards)
  SharedDtor();
}

void HandStartMessage_PlainCards::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void HandStartMessage_PlainCards::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const HandStartMessage_PlainCards& HandStartMessage_PlainCards::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

HandStartMessage_PlainCards* HandStartMessage_PlainCards::default_instance_ = NULL;

HandStartMessage_PlainCards* HandStartMessage_PlainCards::New() const {
  return new HandStartMessage_PlainCards;
}

void HandStartMessage_PlainCards::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<HandStartMessage_PlainCards*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(plaincard1_, plaincard2_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool HandStartMessage_PlainCards::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:HandStartMessage.PlainCards)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 plainCard1 = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &plaincard1_)));
          set_has_plaincard1();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_plainCard2;
        break;
      }

      // required uint32 plainCard2 = 2;
      case 2: {
        if (tag == 16) {
         parse_plainCard2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &plaincard2_)));
          set_has_plaincard2();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:HandStartMessage.PlainCards)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:HandStartMessage.PlainCards)
  return false;
#undef DO_
}

void HandStartMessage_PlainCards::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:HandStartMessage.PlainCards)
  // required uint32 plainCard1 = 1;
  if (has_plaincard1()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->plaincard1(), output);
  }

  // required uint32 plainCard2 = 2;
  if (has_plaincard2()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->plaincard2(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:HandStartMessage.PlainCards)
}

int HandStartMessage_PlainCards::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 plainCard1 = 1;
    if (has_plaincard1()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->plaincard1());
    }

    // required uint32 plainCard2 = 2;
    if (has_plaincard2()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->plaincard2());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void HandStartMessage_PlainCards::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const HandStartMessage_PlainCards*>(&from));
}

void HandStartMessage_PlainCards::MergeFrom(const HandStartMessage_PlainCards& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_plaincard1()) {
      set_plaincard1(from.plaincard1());
    }
    if (from.has_plaincard2()) {
      set_plaincard2(from.plaincard2());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void HandStartMessage_PlainCards::CopyFrom(const HandStartMessage_PlainCards& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HandStartMessage_PlainCards::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void HandStartMessage_PlainCards::Swap(HandStartMessage_PlainCards* other) {
  if (other != this) {
    std::swap(plaincard1_, other->plaincard1_);
    std::swap(plaincard2_, other->plaincard2_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string HandStartMessage_PlainCards::GetTypeName() const {
  return "HandStartMessage.PlainCards";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int HandStartMessage::kGameIdFieldNumber;
const int HandStartMessage::kPlainCardsFieldNumber;
const int HandStartMessage::kEncryptedCardsFieldNumber;
const int HandStartMessage::kSmallBlindFieldNumber;
const int HandStartMessage::kSeatStatesFieldNumber;
const int HandStartMessage::kDealerPlayerIdFieldNumber;
#endif  // !_MSC_VER

HandStartMessage::HandStartMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:HandStartMessage)
}

void HandStartMessage::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  plaincards_ = const_cast< ::HandStartMessage_PlainCards*>(
      ::HandStartMessage_PlainCards::internal_default_instance());
#else
  plaincards_ = const_cast< ::HandStartMessage_PlainCards*>(&::HandStartMessage_PlainCards::default_instance());
#endif
}

HandStartMessage::HandStartMessage(const HandStartMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:HandStartMessage)
}

void HandStartMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  gameid_ = 0u;
  plaincards_ = NULL;
  encryptedcards_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  smallblind_ = 0u;
  dealerplayerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

HandStartMessage::~HandStartMessage() {
  // @@protoc_insertion_point(destructor:HandStartMessage)
  SharedDtor();
}

void HandStartMessage::SharedDtor() {
  if (encryptedcards_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete encryptedcards_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete plaincards_;
  }
}

void HandStartMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const HandStartMessage& HandStartMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

HandStartMessage* HandStartMessage::default_instance_ = NULL;

HandStartMessage* HandStartMessage::New() const {
  return new HandStartMessage;
}

void HandStartMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<HandStartMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 47) {
    ZR_(gameid_, smallblind_);
    if (has_plaincards()) {
      if (plaincards_ != NULL) plaincards_->::HandStartMessage_PlainCards::Clear();
    }
    if (has_encryptedcards()) {
      if (encryptedcards_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        encryptedcards_->clear();
      }
    }
    dealerplayerid_ = 0u;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  seatstates_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool HandStartMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:HandStartMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_plainCards;
        break;
      }

      // optional .HandStartMessage.PlainCards plainCards = 2;
      case 2: {
        if (tag == 18) {
         parse_plainCards:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_plaincards()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_encryptedCards;
        break;
      }

      // optional bytes encryptedCards = 3;
      case 3: {
        if (tag == 26) {
         parse_encryptedCards:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_encryptedcards()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_smallBlind;
        break;
      }

      // required uint32 smallBlind = 4;
      case 4: {
        if (tag == 32) {
         parse_smallBlind:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &smallblind_)));
          set_has_smallblind();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_seatStates;
        break;
      }

      // repeated .NetPlayerState seatStates = 5;
      case 5: {
        if (tag == 40) {
         parse_seatStates:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetPlayerState_IsValid(value)) {
            add_seatstates(static_cast< ::NetPlayerState >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else if (tag == 42) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline(
                 input,
                 &::NetPlayerState_IsValid,
                 this->mutable_seatstates())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_seatStates;
        if (input->ExpectTag(48)) goto parse_dealerPlayerId;
        break;
      }

      // optional uint32 dealerPlayerId = 6;
      case 6: {
        if (tag == 48) {
         parse_dealerPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &dealerplayerid_)));
          set_has_dealerplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:HandStartMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:HandStartMessage)
  return false;
#undef DO_
}

void HandStartMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:HandStartMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // optional .HandStartMessage.PlainCards plainCards = 2;
  if (has_plaincards()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->plaincards(), output);
  }

  // optional bytes encryptedCards = 3;
  if (has_encryptedcards()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->encryptedcards(), output);
  }

  // required uint32 smallBlind = 4;
  if (has_smallblind()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->smallblind(), output);
  }

  // repeated .NetPlayerState seatStates = 5;
  for (int i = 0; i < this->seatstates_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->seatstates(i), output);
  }

  // optional uint32 dealerPlayerId = 6;
  if (has_dealerplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->dealerplayerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:HandStartMessage)
}

int HandStartMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // optional .HandStartMessage.PlainCards plainCards = 2;
    if (has_plaincards()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->plaincards());
    }

    // optional bytes encryptedCards = 3;
    if (has_encryptedcards()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->encryptedcards());
    }

    // required uint32 smallBlind = 4;
    if (has_smallblind()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->smallblind());
    }

    // optional uint32 dealerPlayerId = 6;
    if (has_dealerplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->dealerplayerid());
    }

  }
  // repeated .NetPlayerState seatStates = 5;
  {
    int data_size = 0;
    for (int i = 0; i < this->seatstates_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
        this->seatstates(i));
    }
    total_size += 1 * this->seatstates_size() + data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void HandStartMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const HandStartMessage*>(&from));
}

void HandStartMessage::MergeFrom(const HandStartMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  seatstates_.MergeFrom(from.seatstates_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_plaincards()) {
      mutable_plaincards()->::HandStartMessage_PlainCards::MergeFrom(from.plaincards());
    }
    if (from.has_encryptedcards()) {
      set_encryptedcards(from.encryptedcards());
    }
    if (from.has_smallblind()) {
      set_smallblind(from.smallblind());
    }
    if (from.has_dealerplayerid()) {
      set_dealerplayerid(from.dealerplayerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void HandStartMessage::CopyFrom(const HandStartMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HandStartMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000009) != 0x00000009) return false;

  if (has_plaincards()) {
    if (!this->plaincards().IsInitialized()) return false;
  }
  return true;
}

void HandStartMessage::Swap(HandStartMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(plaincards_, other->plaincards_);
    std::swap(encryptedcards_, other->encryptedcards_);
    std::swap(smallblind_, other->smallblind_);
    seatstates_.Swap(&other->seatstates_);
    std::swap(dealerplayerid_, other->dealerplayerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string HandStartMessage::GetTypeName() const {
  return "HandStartMessage";
}


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

#ifndef _MSC_VER
const int PlayersTurnMessage::kGameIdFieldNumber;
const int PlayersTurnMessage::kPlayerIdFieldNumber;
const int PlayersTurnMessage::kGameStateFieldNumber;
#endif  // !_MSC_VER

PlayersTurnMessage::PlayersTurnMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PlayersTurnMessage)
}

void PlayersTurnMessage::InitAsDefaultInstance() {
}

PlayersTurnMessage::PlayersTurnMessage(const PlayersTurnMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PlayersTurnMessage)
}

void PlayersTurnMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  gamestate_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PlayersTurnMessage::~PlayersTurnMessage() {
  // @@protoc_insertion_point(destructor:PlayersTurnMessage)
  SharedDtor();
}

void PlayersTurnMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void PlayersTurnMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PlayersTurnMessage& PlayersTurnMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

PlayersTurnMessage* PlayersTurnMessage::default_instance_ = NULL;

PlayersTurnMessage* PlayersTurnMessage::New() const {
  return new PlayersTurnMessage;
}

void PlayersTurnMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<PlayersTurnMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, gamestate_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PlayersTurnMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PlayersTurnMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_gameState;
        break;
      }

      // required .NetGameState gameState = 3;
      case 3: {
        if (tag == 24) {
         parse_gameState:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetGameState_IsValid(value)) {
            set_gamestate(static_cast< ::NetGameState >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PlayersTurnMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PlayersTurnMessage)
  return false;
#undef DO_
}

void PlayersTurnMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PlayersTurnMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  // required .NetGameState gameState = 3;
  if (has_gamestate()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->gamestate(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PlayersTurnMessage)
}

int PlayersTurnMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required .NetGameState gameState = 3;
    if (has_gamestate()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->gamestate());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PlayersTurnMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PlayersTurnMessage*>(&from));
}

void PlayersTurnMessage::MergeFrom(const PlayersTurnMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_gamestate()) {
      set_gamestate(from.gamestate());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PlayersTurnMessage::CopyFrom(const PlayersTurnMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlayersTurnMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void PlayersTurnMessage::Swap(PlayersTurnMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(gamestate_, other->gamestate_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PlayersTurnMessage::GetTypeName() const {
  return "PlayersTurnMessage";
}


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

#ifndef _MSC_VER
const int MyActionRequestMessage::kGameIdFieldNumber;
const int MyActionRequestMessage::kHandNumFieldNumber;
const int MyActionRequestMessage::kGameStateFieldNumber;
const int MyActionRequestMessage::kMyActionFieldNumber;
const int MyActionRequestMessage::kMyRelativeBetFieldNumber;
#endif  // !_MSC_VER

MyActionRequestMessage::MyActionRequestMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:MyActionRequestMessage)
}

void MyActionRequestMessage::InitAsDefaultInstance() {
}

MyActionRequestMessage::MyActionRequestMessage(const MyActionRequestMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:MyActionRequestMessage)
}

void MyActionRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  handnum_ = 0u;
  gamestate_ = 0;
  myaction_ = 0;
  myrelativebet_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

MyActionRequestMessage::~MyActionRequestMessage() {
  // @@protoc_insertion_point(destructor:MyActionRequestMessage)
  SharedDtor();
}

void MyActionRequestMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void MyActionRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const MyActionRequestMessage& MyActionRequestMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

MyActionRequestMessage* MyActionRequestMessage::default_instance_ = NULL;

MyActionRequestMessage* MyActionRequestMessage::New() const {
  return new MyActionRequestMessage;
}

void MyActionRequestMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<MyActionRequestMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 31) {
    ZR_(gameid_, myrelativebet_);
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool MyActionRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:MyActionRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_handNum;
        break;
      }

      // required uint32 handNum = 2;
      case 2: {
        if (tag == 16) {
         parse_handNum:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &handnum_)));
          set_has_handnum();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_gameState;
        break;
      }

      // required .NetGameState gameState = 3;
      case 3: {
        if (tag == 24) {
         parse_gameState:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetGameState_IsValid(value)) {
            set_gamestate(static_cast< ::NetGameState >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_myAction;
        break;
      }

      // required .NetPlayerAction myAction = 4;
      case 4: {
        if (tag == 32) {
         parse_myAction:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetPlayerAction_IsValid(value)) {
            set_myaction(static_cast< ::NetPlayerAction >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_myRelativeBet;
        break;
      }

      // required uint32 myRelativeBet = 5;
      case 5: {
        if (tag == 40) {
         parse_myRelativeBet:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &myrelativebet_)));
          set_has_myrelativebet();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:MyActionRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:MyActionRequestMessage)
  return false;
#undef DO_
}

void MyActionRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:MyActionRequestMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 handNum = 2;
  if (has_handnum()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->handnum(), output);
  }

  // required .NetGameState gameState = 3;
  if (has_gamestate()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->gamestate(), output);
  }

  // required .NetPlayerAction myAction = 4;
  if (has_myaction()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->myaction(), output);
  }

  // required uint32 myRelativeBet = 5;
  if (has_myrelativebet()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->myrelativebet(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:MyActionRequestMessage)
}

int MyActionRequestMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 handNum = 2;
    if (has_handnum()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->handnum());
    }

    // required .NetGameState gameState = 3;
    if (has_gamestate()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->gamestate());
    }

    // required .NetPlayerAction myAction = 4;
    if (has_myaction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->myaction());
    }

    // required uint32 myRelativeBet = 5;
    if (has_myrelativebet()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->myrelativebet());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void MyActionRequestMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const MyActionRequestMessage*>(&from));
}

void MyActionRequestMessage::MergeFrom(const MyActionRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_handnum()) {
      set_handnum(from.handnum());
    }
    if (from.has_gamestate()) {
      set_gamestate(from.gamestate());
    }
    if (from.has_myaction()) {
      set_myaction(from.myaction());
    }
    if (from.has_myrelativebet()) {
      set_myrelativebet(from.myrelativebet());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void MyActionRequestMessage::CopyFrom(const MyActionRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MyActionRequestMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;

  return true;
}

void MyActionRequestMessage::Swap(MyActionRequestMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(handnum_, other->handnum_);
    std::swap(gamestate_, other->gamestate_);
    std::swap(myaction_, other->myaction_);
    std::swap(myrelativebet_, other->myrelativebet_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string MyActionRequestMessage::GetTypeName() const {
  return "MyActionRequestMessage";
}


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

bool YourActionRejectedMessage_RejectionReason_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const YourActionRejectedMessage_RejectionReason YourActionRejectedMessage::rejectedInvalidGameState;
const YourActionRejectedMessage_RejectionReason YourActionRejectedMessage::rejectedNotYourTurn;
const YourActionRejectedMessage_RejectionReason YourActionRejectedMessage::rejectedActionNotAllowed;
const YourActionRejectedMessage_RejectionReason YourActionRejectedMessage::RejectionReason_MIN;
const YourActionRejectedMessage_RejectionReason YourActionRejectedMessage::RejectionReason_MAX;
const int YourActionRejectedMessage::RejectionReason_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int YourActionRejectedMessage::kGameIdFieldNumber;
const int YourActionRejectedMessage::kGameStateFieldNumber;
const int YourActionRejectedMessage::kYourActionFieldNumber;
const int YourActionRejectedMessage::kYourRelativeBetFieldNumber;
const int YourActionRejectedMessage::kRejectionReasonFieldNumber;
#endif  // !_MSC_VER

YourActionRejectedMessage::YourActionRejectedMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:YourActionRejectedMessage)
}

void YourActionRejectedMessage::InitAsDefaultInstance() {
}

YourActionRejectedMessage::YourActionRejectedMessage(const YourActionRejectedMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:YourActionRejectedMessage)
}

void YourActionRejectedMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  gamestate_ = 0;
  youraction_ = 0;
  yourrelativebet_ = 0u;
  rejectionreason_ = 1;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

YourActionRejectedMessage::~YourActionRejectedMessage() {
  // @@protoc_insertion_point(destructor:YourActionRejectedMessage)
  SharedDtor();
}

void YourActionRejectedMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void YourActionRejectedMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const YourActionRejectedMessage& YourActionRejectedMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

YourActionRejectedMessage* YourActionRejectedMessage::default_instance_ = NULL;

YourActionRejectedMessage* YourActionRejectedMessage::New() const {
  return new YourActionRejectedMessage;
}

void YourActionRejectedMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<YourActionRejectedMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 31) {
    ZR_(gameid_, yourrelativebet_);
    rejectionreason_ = 1;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool YourActionRejectedMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:YourActionRejectedMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_gameState;
        break;
      }

      // required .NetGameState gameState = 2;
      case 2: {
        if (tag == 16) {
         parse_gameState:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetGameState_IsValid(value)) {
            set_gamestate(static_cast< ::NetGameState >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_yourAction;
        break;
      }

      // required .NetPlayerAction yourAction = 3;
      case 3: {
        if (tag == 24) {
         parse_yourAction:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetPlayerAction_IsValid(value)) {
            set_youraction(static_cast< ::NetPlayerAction >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_yourRelativeBet;
        break;
      }

      // required uint32 yourRelativeBet = 4;
      case 4: {
        if (tag == 32) {
         parse_yourRelativeBet:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &yourrelativebet_)));
          set_has_yourrelativebet();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_rejectionReason;
        break;
      }

      // required .YourActionRejectedMessage.RejectionReason rejectionReason = 5;
      case 5: {
        if (tag == 40) {
         parse_rejectionReason:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::YourActionRejectedMessage_RejectionReason_IsValid(value)) {
            set_rejectionreason(static_cast< ::YourActionRejectedMessage_RejectionReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:YourActionRejectedMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:YourActionRejectedMessage)
  return false;
#undef DO_
}

void YourActionRejectedMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:YourActionRejectedMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required .NetGameState gameState = 2;
  if (has_gamestate()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->gamestate(), output);
  }

  // required .NetPlayerAction yourAction = 3;
  if (has_youraction()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->youraction(), output);
  }

  // required uint32 yourRelativeBet = 4;
  if (has_yourrelativebet()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->yourrelativebet(), output);
  }

  // required .YourActionRejectedMessage.RejectionReason rejectionReason = 5;
  if (has_rejectionreason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->rejectionreason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:YourActionRejectedMessage)
}

int YourActionRejectedMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required .NetGameState gameState = 2;
    if (has_gamestate()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->gamestate());
    }

    // required .NetPlayerAction yourAction = 3;
    if (has_youraction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->youraction());
    }

    // required uint32 yourRelativeBet = 4;
    if (has_yourrelativebet()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->yourrelativebet());
    }

    // required .YourActionRejectedMessage.RejectionReason rejectionReason = 5;
    if (has_rejectionreason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->rejectionreason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void YourActionRejectedMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const YourActionRejectedMessage*>(&from));
}

void YourActionRejectedMessage::MergeFrom(const YourActionRejectedMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_gamestate()) {
      set_gamestate(from.gamestate());
    }
    if (from.has_youraction()) {
      set_youraction(from.youraction());
    }
    if (from.has_yourrelativebet()) {
      set_yourrelativebet(from.yourrelativebet());
    }
    if (from.has_rejectionreason()) {
      set_rejectionreason(from.rejectionreason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void YourActionRejectedMessage::CopyFrom(const YourActionRejectedMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool YourActionRejectedMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;

  return true;
}

void YourActionRejectedMessage::Swap(YourActionRejectedMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(gamestate_, other->gamestate_);
    std::swap(youraction_, other->youraction_);
    std::swap(yourrelativebet_, other->yourrelativebet_);
    std::swap(rejectionreason_, other->rejectionreason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string YourActionRejectedMessage::GetTypeName() const {
  return "YourActionRejectedMessage";
}


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

#ifndef _MSC_VER
const int PlayersActionDoneMessage::kGameIdFieldNumber;
const int PlayersActionDoneMessage::kPlayerIdFieldNumber;
const int PlayersActionDoneMessage::kGameStateFieldNumber;
const int PlayersActionDoneMessage::kPlayerActionFieldNumber;
const int PlayersActionDoneMessage::kTotalPlayerBetFieldNumber;
const int PlayersActionDoneMessage::kPlayerMoneyFieldNumber;
const int PlayersActionDoneMessage::kHighestSetFieldNumber;
const int PlayersActionDoneMessage::kMinimumRaiseFieldNumber;
#endif  // !_MSC_VER

PlayersActionDoneMessage::PlayersActionDoneMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PlayersActionDoneMessage)
}

void PlayersActionDoneMessage::InitAsDefaultInstance() {
}

PlayersActionDoneMessage::PlayersActionDoneMessage(const PlayersActionDoneMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PlayersActionDoneMessage)
}

void PlayersActionDoneMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  gamestate_ = 0;
  playeraction_ = 0;
  totalplayerbet_ = 0u;
  playermoney_ = 0u;
  highestset_ = 0u;
  minimumraise_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PlayersActionDoneMessage::~PlayersActionDoneMessage() {
  // @@protoc_insertion_point(destructor:PlayersActionDoneMessage)
  SharedDtor();
}

void PlayersActionDoneMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void PlayersActionDoneMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PlayersActionDoneMessage& PlayersActionDoneMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

PlayersActionDoneMessage* PlayersActionDoneMessage::default_instance_ = NULL;

PlayersActionDoneMessage* PlayersActionDoneMessage::New() const {
  return new PlayersActionDoneMessage;
}

void PlayersActionDoneMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<PlayersActionDoneMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 255) {
    ZR_(gameid_, minimumraise_);
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PlayersActionDoneMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PlayersActionDoneMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_gameState;
        break;
      }

      // required .NetGameState gameState = 3;
      case 3: {
        if (tag == 24) {
         parse_gameState:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetGameState_IsValid(value)) {
            set_gamestate(static_cast< ::NetGameState >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_playerAction;
        break;
      }

      // required .NetPlayerAction playerAction = 4;
      case 4: {
        if (tag == 32) {
         parse_playerAction:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::NetPlayerAction_IsValid(value)) {
            set_playeraction(static_cast< ::NetPlayerAction >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_totalPlayerBet;
        break;
      }

      // required uint32 totalPlayerBet = 5;
      case 5: {
        if (tag == 40) {
         parse_totalPlayerBet:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &totalplayerbet_)));
          set_has_totalplayerbet();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_playerMoney;
        break;
      }

      // required uint32 playerMoney = 6;
      case 6: {
        if (tag == 48) {
         parse_playerMoney:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playermoney_)));
          set_has_playermoney();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_highestSet;
        break;
      }

      // required uint32 highestSet = 7;
      case 7: {
        if (tag == 56) {
         parse_highestSet:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &highestset_)));
          set_has_highestset();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_minimumRaise;
        break;
      }

      // required uint32 minimumRaise = 8;
      case 8: {
        if (tag == 64) {
         parse_minimumRaise:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &minimumraise_)));
          set_has_minimumraise();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PlayersActionDoneMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PlayersActionDoneMessage)
  return false;
#undef DO_
}

void PlayersActionDoneMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PlayersActionDoneMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  // required .NetGameState gameState = 3;
  if (has_gamestate()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->gamestate(), output);
  }

  // required .NetPlayerAction playerAction = 4;
  if (has_playeraction()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->playeraction(), output);
  }

  // required uint32 totalPlayerBet = 5;
  if (has_totalplayerbet()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->totalplayerbet(), output);
  }

  // required uint32 playerMoney = 6;
  if (has_playermoney()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->playermoney(), output);
  }

  // required uint32 highestSet = 7;
  if (has_highestset()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->highestset(), output);
  }

  // required uint32 minimumRaise = 8;
  if (has_minimumraise()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->minimumraise(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PlayersActionDoneMessage)
}

int PlayersActionDoneMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required .NetGameState gameState = 3;
    if (has_gamestate()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->gamestate());
    }

    // required .NetPlayerAction playerAction = 4;
    if (has_playeraction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->playeraction());
    }

    // required uint32 totalPlayerBet = 5;
    if (has_totalplayerbet()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->totalplayerbet());
    }

    // required uint32 playerMoney = 6;
    if (has_playermoney()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playermoney());
    }

    // required uint32 highestSet = 7;
    if (has_highestset()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->highestset());
    }

    // required uint32 minimumRaise = 8;
    if (has_minimumraise()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->minimumraise());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PlayersActionDoneMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PlayersActionDoneMessage*>(&from));
}

void PlayersActionDoneMessage::MergeFrom(const PlayersActionDoneMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_gamestate()) {
      set_gamestate(from.gamestate());
    }
    if (from.has_playeraction()) {
      set_playeraction(from.playeraction());
    }
    if (from.has_totalplayerbet()) {
      set_totalplayerbet(from.totalplayerbet());
    }
    if (from.has_playermoney()) {
      set_playermoney(from.playermoney());
    }
    if (from.has_highestset()) {
      set_highestset(from.highestset());
    }
    if (from.has_minimumraise()) {
      set_minimumraise(from.minimumraise());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PlayersActionDoneMessage::CopyFrom(const PlayersActionDoneMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlayersActionDoneMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x000000ff) != 0x000000ff) return false;

  return true;
}

void PlayersActionDoneMessage::Swap(PlayersActionDoneMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(gamestate_, other->gamestate_);
    std::swap(playeraction_, other->playeraction_);
    std::swap(totalplayerbet_, other->totalplayerbet_);
    std::swap(playermoney_, other->playermoney_);
    std::swap(highestset_, other->highestset_);
    std::swap(minimumraise_, other->minimumraise_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PlayersActionDoneMessage::GetTypeName() const {
  return "PlayersActionDoneMessage";
}


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

#ifndef _MSC_VER
const int DealFlopCardsMessage::kGameIdFieldNumber;
const int DealFlopCardsMessage::kFlopCard1FieldNumber;
const int DealFlopCardsMessage::kFlopCard2FieldNumber;
const int DealFlopCardsMessage::kFlopCard3FieldNumber;
#endif  // !_MSC_VER

DealFlopCardsMessage::DealFlopCardsMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:DealFlopCardsMessage)
}

void DealFlopCardsMessage::InitAsDefaultInstance() {
}

DealFlopCardsMessage::DealFlopCardsMessage(const DealFlopCardsMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:DealFlopCardsMessage)
}

void DealFlopCardsMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  flopcard1_ = 0u;
  flopcard2_ = 0u;
  flopcard3_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DealFlopCardsMessage::~DealFlopCardsMessage() {
  // @@protoc_insertion_point(destructor:DealFlopCardsMessage)
  SharedDtor();
}

void DealFlopCardsMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void DealFlopCardsMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DealFlopCardsMessage& DealFlopCardsMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

DealFlopCardsMessage* DealFlopCardsMessage::default_instance_ = NULL;

DealFlopCardsMessage* DealFlopCardsMessage::New() const {
  return new DealFlopCardsMessage;
}

void DealFlopCardsMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<DealFlopCardsMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, flopcard3_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool DealFlopCardsMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:DealFlopCardsMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_flopCard1;
        break;
      }

      // required uint32 flopCard1 = 2;
      case 2: {
        if (tag == 16) {
         parse_flopCard1:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &flopcard1_)));
          set_has_flopcard1();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_flopCard2;
        break;
      }

      // required uint32 flopCard2 = 3;
      case 3: {
        if (tag == 24) {
         parse_flopCard2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &flopcard2_)));
          set_has_flopcard2();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_flopCard3;
        break;
      }

      // required uint32 flopCard3 = 4;
      case 4: {
        if (tag == 32) {
         parse_flopCard3:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &flopcard3_)));
          set_has_flopcard3();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:DealFlopCardsMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:DealFlopCardsMessage)
  return false;
#undef DO_
}

void DealFlopCardsMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:DealFlopCardsMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 flopCard1 = 2;
  if (has_flopcard1()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->flopcard1(), output);
  }

  // required uint32 flopCard2 = 3;
  if (has_flopcard2()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->flopcard2(), output);
  }

  // required uint32 flopCard3 = 4;
  if (has_flopcard3()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->flopcard3(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:DealFlopCardsMessage)
}

int DealFlopCardsMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 flopCard1 = 2;
    if (has_flopcard1()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->flopcard1());
    }

    // required uint32 flopCard2 = 3;
    if (has_flopcard2()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->flopcard2());
    }

    // required uint32 flopCard3 = 4;
    if (has_flopcard3()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->flopcard3());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DealFlopCardsMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DealFlopCardsMessage*>(&from));
}

void DealFlopCardsMessage::MergeFrom(const DealFlopCardsMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_flopcard1()) {
      set_flopcard1(from.flopcard1());
    }
    if (from.has_flopcard2()) {
      set_flopcard2(from.flopcard2());
    }
    if (from.has_flopcard3()) {
      set_flopcard3(from.flopcard3());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void DealFlopCardsMessage::CopyFrom(const DealFlopCardsMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DealFlopCardsMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  return true;
}

void DealFlopCardsMessage::Swap(DealFlopCardsMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(flopcard1_, other->flopcard1_);
    std::swap(flopcard2_, other->flopcard2_);
    std::swap(flopcard3_, other->flopcard3_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string DealFlopCardsMessage::GetTypeName() const {
  return "DealFlopCardsMessage";
}


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

#ifndef _MSC_VER
const int DealTurnCardMessage::kGameIdFieldNumber;
const int DealTurnCardMessage::kTurnCardFieldNumber;
#endif  // !_MSC_VER

DealTurnCardMessage::DealTurnCardMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:DealTurnCardMessage)
}

void DealTurnCardMessage::InitAsDefaultInstance() {
}

DealTurnCardMessage::DealTurnCardMessage(const DealTurnCardMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:DealTurnCardMessage)
}

void DealTurnCardMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  turncard_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DealTurnCardMessage::~DealTurnCardMessage() {
  // @@protoc_insertion_point(destructor:DealTurnCardMessage)
  SharedDtor();
}

void DealTurnCardMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void DealTurnCardMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DealTurnCardMessage& DealTurnCardMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

DealTurnCardMessage* DealTurnCardMessage::default_instance_ = NULL;

DealTurnCardMessage* DealTurnCardMessage::New() const {
  return new DealTurnCardMessage;
}

void DealTurnCardMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<DealTurnCardMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, turncard_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool DealTurnCardMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:DealTurnCardMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_turnCard;
        break;
      }

      // required uint32 turnCard = 2;
      case 2: {
        if (tag == 16) {
         parse_turnCard:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &turncard_)));
          set_has_turncard();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:DealTurnCardMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:DealTurnCardMessage)
  return false;
#undef DO_
}

void DealTurnCardMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:DealTurnCardMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 turnCard = 2;
  if (has_turncard()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->turncard(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:DealTurnCardMessage)
}

int DealTurnCardMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 turnCard = 2;
    if (has_turncard()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->turncard());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DealTurnCardMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DealTurnCardMessage*>(&from));
}

void DealTurnCardMessage::MergeFrom(const DealTurnCardMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_turncard()) {
      set_turncard(from.turncard());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void DealTurnCardMessage::CopyFrom(const DealTurnCardMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DealTurnCardMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void DealTurnCardMessage::Swap(DealTurnCardMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(turncard_, other->turncard_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string DealTurnCardMessage::GetTypeName() const {
  return "DealTurnCardMessage";
}


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

#ifndef _MSC_VER
const int DealRiverCardMessage::kGameIdFieldNumber;
const int DealRiverCardMessage::kRiverCardFieldNumber;
#endif  // !_MSC_VER

DealRiverCardMessage::DealRiverCardMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:DealRiverCardMessage)
}

void DealRiverCardMessage::InitAsDefaultInstance() {
}

DealRiverCardMessage::DealRiverCardMessage(const DealRiverCardMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:DealRiverCardMessage)
}

void DealRiverCardMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  rivercard_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DealRiverCardMessage::~DealRiverCardMessage() {
  // @@protoc_insertion_point(destructor:DealRiverCardMessage)
  SharedDtor();
}

void DealRiverCardMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void DealRiverCardMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DealRiverCardMessage& DealRiverCardMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

DealRiverCardMessage* DealRiverCardMessage::default_instance_ = NULL;

DealRiverCardMessage* DealRiverCardMessage::New() const {
  return new DealRiverCardMessage;
}

void DealRiverCardMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<DealRiverCardMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, rivercard_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool DealRiverCardMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:DealRiverCardMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_riverCard;
        break;
      }

      // required uint32 riverCard = 2;
      case 2: {
        if (tag == 16) {
         parse_riverCard:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &rivercard_)));
          set_has_rivercard();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:DealRiverCardMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:DealRiverCardMessage)
  return false;
#undef DO_
}

void DealRiverCardMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:DealRiverCardMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 riverCard = 2;
  if (has_rivercard()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->rivercard(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:DealRiverCardMessage)
}

int DealRiverCardMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 riverCard = 2;
    if (has_rivercard()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->rivercard());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DealRiverCardMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DealRiverCardMessage*>(&from));
}

void DealRiverCardMessage::MergeFrom(const DealRiverCardMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_rivercard()) {
      set_rivercard(from.rivercard());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void DealRiverCardMessage::CopyFrom(const DealRiverCardMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DealRiverCardMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void DealRiverCardMessage::Swap(DealRiverCardMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(rivercard_, other->rivercard_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string DealRiverCardMessage::GetTypeName() const {
  return "DealRiverCardMessage";
}


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

#ifndef _MSC_VER
const int AllInShowCardsMessage_PlayerAllIn::kPlayerIdFieldNumber;
const int AllInShowCardsMessage_PlayerAllIn::kAllInCard1FieldNumber;
const int AllInShowCardsMessage_PlayerAllIn::kAllInCard2FieldNumber;
#endif  // !_MSC_VER

AllInShowCardsMessage_PlayerAllIn::AllInShowCardsMessage_PlayerAllIn()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AllInShowCardsMessage.PlayerAllIn)
}

void AllInShowCardsMessage_PlayerAllIn::InitAsDefaultInstance() {
}

AllInShowCardsMessage_PlayerAllIn::AllInShowCardsMessage_PlayerAllIn(const AllInShowCardsMessage_PlayerAllIn& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AllInShowCardsMessage.PlayerAllIn)
}

void AllInShowCardsMessage_PlayerAllIn::SharedCtor() {
  _cached_size_ = 0;
  playerid_ = 0u;
  allincard1_ = 0u;
  allincard2_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AllInShowCardsMessage_PlayerAllIn::~AllInShowCardsMessage_PlayerAllIn() {
  // @@protoc_insertion_point(destructor:AllInShowCardsMessage.PlayerAllIn)
  SharedDtor();
}

void AllInShowCardsMessage_PlayerAllIn::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AllInShowCardsMessage_PlayerAllIn::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AllInShowCardsMessage_PlayerAllIn& AllInShowCardsMessage_PlayerAllIn::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AllInShowCardsMessage_PlayerAllIn* AllInShowCardsMessage_PlayerAllIn::default_instance_ = NULL;

AllInShowCardsMessage_PlayerAllIn* AllInShowCardsMessage_PlayerAllIn::New() const {
  return new AllInShowCardsMessage_PlayerAllIn;
}

void AllInShowCardsMessage_PlayerAllIn::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<AllInShowCardsMessage_PlayerAllIn*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(playerid_, allincard2_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AllInShowCardsMessage_PlayerAllIn::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AllInShowCardsMessage.PlayerAllIn)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 playerId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_allInCard1;
        break;
      }

      // required uint32 allInCard1 = 2;
      case 2: {
        if (tag == 16) {
         parse_allInCard1:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &allincard1_)));
          set_has_allincard1();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_allInCard2;
        break;
      }

      // required uint32 allInCard2 = 3;
      case 3: {
        if (tag == 24) {
         parse_allInCard2:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &allincard2_)));
          set_has_allincard2();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AllInShowCardsMessage.PlayerAllIn)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AllInShowCardsMessage.PlayerAllIn)
  return false;
#undef DO_
}

void AllInShowCardsMessage_PlayerAllIn::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AllInShowCardsMessage.PlayerAllIn)
  // required uint32 playerId = 1;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->playerid(), output);
  }

  // required uint32 allInCard1 = 2;
  if (has_allincard1()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->allincard1(), output);
  }

  // required uint32 allInCard2 = 3;
  if (has_allincard2()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->allincard2(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AllInShowCardsMessage.PlayerAllIn)
}

int AllInShowCardsMessage_PlayerAllIn::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 playerId = 1;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required uint32 allInCard1 = 2;
    if (has_allincard1()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->allincard1());
    }

    // required uint32 allInCard2 = 3;
    if (has_allincard2()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->allincard2());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AllInShowCardsMessage_PlayerAllIn::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AllInShowCardsMessage_PlayerAllIn*>(&from));
}

void AllInShowCardsMessage_PlayerAllIn::MergeFrom(const AllInShowCardsMessage_PlayerAllIn& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_allincard1()) {
      set_allincard1(from.allincard1());
    }
    if (from.has_allincard2()) {
      set_allincard2(from.allincard2());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AllInShowCardsMessage_PlayerAllIn::CopyFrom(const AllInShowCardsMessage_PlayerAllIn& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AllInShowCardsMessage_PlayerAllIn::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void AllInShowCardsMessage_PlayerAllIn::Swap(AllInShowCardsMessage_PlayerAllIn* other) {
  if (other != this) {
    std::swap(playerid_, other->playerid_);
    std::swap(allincard1_, other->allincard1_);
    std::swap(allincard2_, other->allincard2_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AllInShowCardsMessage_PlayerAllIn::GetTypeName() const {
  return "AllInShowCardsMessage.PlayerAllIn";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int AllInShowCardsMessage::kGameIdFieldNumber;
const int AllInShowCardsMessage::kPlayersAllInFieldNumber;
#endif  // !_MSC_VER

AllInShowCardsMessage::AllInShowCardsMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AllInShowCardsMessage)
}

void AllInShowCardsMessage::InitAsDefaultInstance() {
}

AllInShowCardsMessage::AllInShowCardsMessage(const AllInShowCardsMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AllInShowCardsMessage)
}

void AllInShowCardsMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AllInShowCardsMessage::~AllInShowCardsMessage() {
  // @@protoc_insertion_point(destructor:AllInShowCardsMessage)
  SharedDtor();
}

void AllInShowCardsMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AllInShowCardsMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AllInShowCardsMessage& AllInShowCardsMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AllInShowCardsMessage* AllInShowCardsMessage::default_instance_ = NULL;

AllInShowCardsMessage* AllInShowCardsMessage::New() const {
  return new AllInShowCardsMessage;
}

void AllInShowCardsMessage::Clear() {
  gameid_ = 0u;
  playersallin_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AllInShowCardsMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AllInShowCardsMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_playersAllIn;
        break;
      }

      // repeated .AllInShowCardsMessage.PlayerAllIn playersAllIn = 2;
      case 2: {
        if (tag == 18) {
         parse_playersAllIn:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_playersallin()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_playersAllIn;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AllInShowCardsMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AllInShowCardsMessage)
  return false;
#undef DO_
}

void AllInShowCardsMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AllInShowCardsMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // repeated .AllInShowCardsMessage.PlayerAllIn playersAllIn = 2;
  for (int i = 0; i < this->playersallin_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->playersallin(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AllInShowCardsMessage)
}

int AllInShowCardsMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

  }
  // repeated .AllInShowCardsMessage.PlayerAllIn playersAllIn = 2;
  total_size += 1 * this->playersallin_size();
  for (int i = 0; i < this->playersallin_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->playersallin(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AllInShowCardsMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AllInShowCardsMessage*>(&from));
}

void AllInShowCardsMessage::MergeFrom(const AllInShowCardsMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  playersallin_.MergeFrom(from.playersallin_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AllInShowCardsMessage::CopyFrom(const AllInShowCardsMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AllInShowCardsMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->playersallin())) return false;
  return true;
}

void AllInShowCardsMessage::Swap(AllInShowCardsMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    playersallin_.Swap(&other->playersallin_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AllInShowCardsMessage::GetTypeName() const {
  return "AllInShowCardsMessage";
}


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

#ifndef _MSC_VER
const int EndOfHandShowCardsMessage::kGameIdFieldNumber;
const int EndOfHandShowCardsMessage::kPlayerResultsFieldNumber;
#endif  // !_MSC_VER

EndOfHandShowCardsMessage::EndOfHandShowCardsMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:EndOfHandShowCardsMessage)
}

void EndOfHandShowCardsMessage::InitAsDefaultInstance() {
}

EndOfHandShowCardsMessage::EndOfHandShowCardsMessage(const EndOfHandShowCardsMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:EndOfHandShowCardsMessage)
}

void EndOfHandShowCardsMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

EndOfHandShowCardsMessage::~EndOfHandShowCardsMessage() {
  // @@protoc_insertion_point(destructor:EndOfHandShowCardsMessage)
  SharedDtor();
}

void EndOfHandShowCardsMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void EndOfHandShowCardsMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const EndOfHandShowCardsMessage& EndOfHandShowCardsMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

EndOfHandShowCardsMessage* EndOfHandShowCardsMessage::default_instance_ = NULL;

EndOfHandShowCardsMessage* EndOfHandShowCardsMessage::New() const {
  return new EndOfHandShowCardsMessage;
}

void EndOfHandShowCardsMessage::Clear() {
  gameid_ = 0u;
  playerresults_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool EndOfHandShowCardsMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:EndOfHandShowCardsMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_playerResults;
        break;
      }

      // repeated .PlayerResult playerResults = 2;
      case 2: {
        if (tag == 18) {
         parse_playerResults:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_playerresults()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_playerResults;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:EndOfHandShowCardsMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:EndOfHandShowCardsMessage)
  return false;
#undef DO_
}

void EndOfHandShowCardsMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:EndOfHandShowCardsMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // repeated .PlayerResult playerResults = 2;
  for (int i = 0; i < this->playerresults_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->playerresults(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:EndOfHandShowCardsMessage)
}

int EndOfHandShowCardsMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

  }
  // repeated .PlayerResult playerResults = 2;
  total_size += 1 * this->playerresults_size();
  for (int i = 0; i < this->playerresults_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->playerresults(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void EndOfHandShowCardsMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const EndOfHandShowCardsMessage*>(&from));
}

void EndOfHandShowCardsMessage::MergeFrom(const EndOfHandShowCardsMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  playerresults_.MergeFrom(from.playerresults_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void EndOfHandShowCardsMessage::CopyFrom(const EndOfHandShowCardsMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool EndOfHandShowCardsMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->playerresults())) return false;
  return true;
}

void EndOfHandShowCardsMessage::Swap(EndOfHandShowCardsMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    playerresults_.Swap(&other->playerresults_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string EndOfHandShowCardsMessage::GetTypeName() const {
  return "EndOfHandShowCardsMessage";
}


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

#ifndef _MSC_VER
const int EndOfHandHideCardsMessage::kGameIdFieldNumber;
const int EndOfHandHideCardsMessage::kPlayerIdFieldNumber;
const int EndOfHandHideCardsMessage::kMoneyWonFieldNumber;
const int EndOfHandHideCardsMessage::kPlayerMoneyFieldNumber;
#endif  // !_MSC_VER

EndOfHandHideCardsMessage::EndOfHandHideCardsMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:EndOfHandHideCardsMessage)
}

void EndOfHandHideCardsMessage::InitAsDefaultInstance() {
}

EndOfHandHideCardsMessage::EndOfHandHideCardsMessage(const EndOfHandHideCardsMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:EndOfHandHideCardsMessage)
}

void EndOfHandHideCardsMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  moneywon_ = 0u;
  playermoney_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

EndOfHandHideCardsMessage::~EndOfHandHideCardsMessage() {
  // @@protoc_insertion_point(destructor:EndOfHandHideCardsMessage)
  SharedDtor();
}

void EndOfHandHideCardsMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void EndOfHandHideCardsMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const EndOfHandHideCardsMessage& EndOfHandHideCardsMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

EndOfHandHideCardsMessage* EndOfHandHideCardsMessage::default_instance_ = NULL;

EndOfHandHideCardsMessage* EndOfHandHideCardsMessage::New() const {
  return new EndOfHandHideCardsMessage;
}

void EndOfHandHideCardsMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<EndOfHandHideCardsMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playermoney_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool EndOfHandHideCardsMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:EndOfHandHideCardsMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_moneyWon;
        break;
      }

      // required uint32 moneyWon = 3;
      case 3: {
        if (tag == 24) {
         parse_moneyWon:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &moneywon_)));
          set_has_moneywon();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_playerMoney;
        break;
      }

      // required uint32 playerMoney = 4;
      case 4: {
        if (tag == 32) {
         parse_playerMoney:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playermoney_)));
          set_has_playermoney();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:EndOfHandHideCardsMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:EndOfHandHideCardsMessage)
  return false;
#undef DO_
}

void EndOfHandHideCardsMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:EndOfHandHideCardsMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  // required uint32 moneyWon = 3;
  if (has_moneywon()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->moneywon(), output);
  }

  // required uint32 playerMoney = 4;
  if (has_playermoney()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->playermoney(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:EndOfHandHideCardsMessage)
}

int EndOfHandHideCardsMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required uint32 moneyWon = 3;
    if (has_moneywon()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->moneywon());
    }

    // required uint32 playerMoney = 4;
    if (has_playermoney()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playermoney());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void EndOfHandHideCardsMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const EndOfHandHideCardsMessage*>(&from));
}

void EndOfHandHideCardsMessage::MergeFrom(const EndOfHandHideCardsMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_moneywon()) {
      set_moneywon(from.moneywon());
    }
    if (from.has_playermoney()) {
      set_playermoney(from.playermoney());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void EndOfHandHideCardsMessage::CopyFrom(const EndOfHandHideCardsMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool EndOfHandHideCardsMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  return true;
}

void EndOfHandHideCardsMessage::Swap(EndOfHandHideCardsMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(moneywon_, other->moneywon_);
    std::swap(playermoney_, other->playermoney_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string EndOfHandHideCardsMessage::GetTypeName() const {
  return "EndOfHandHideCardsMessage";
}


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

#ifndef _MSC_VER
#endif  // !_MSC_VER

ShowMyCardsRequestMessage::ShowMyCardsRequestMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ShowMyCardsRequestMessage)
}

void ShowMyCardsRequestMessage::InitAsDefaultInstance() {
}

ShowMyCardsRequestMessage::ShowMyCardsRequestMessage(const ShowMyCardsRequestMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ShowMyCardsRequestMessage)
}

void ShowMyCardsRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ShowMyCardsRequestMessage::~ShowMyCardsRequestMessage() {
  // @@protoc_insertion_point(destructor:ShowMyCardsRequestMessage)
  SharedDtor();
}

void ShowMyCardsRequestMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ShowMyCardsRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ShowMyCardsRequestMessage& ShowMyCardsRequestMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

ShowMyCardsRequestMessage* ShowMyCardsRequestMessage::default_instance_ = NULL;

ShowMyCardsRequestMessage* ShowMyCardsRequestMessage::New() const {
  return new ShowMyCardsRequestMessage;
}

void ShowMyCardsRequestMessage::Clear() {
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ShowMyCardsRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ShowMyCardsRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0 ||
        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormatLite::SkipField(
        input, tag, &unknown_fields_stream));
  }
success:
  // @@protoc_insertion_point(parse_success:ShowMyCardsRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ShowMyCardsRequestMessage)
  return false;
#undef DO_
}

void ShowMyCardsRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ShowMyCardsRequestMessage)
  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ShowMyCardsRequestMessage)
}

int ShowMyCardsRequestMessage::ByteSize() const {
  int total_size = 0;

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ShowMyCardsRequestMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ShowMyCardsRequestMessage*>(&from));
}

void ShowMyCardsRequestMessage::MergeFrom(const ShowMyCardsRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ShowMyCardsRequestMessage::CopyFrom(const ShowMyCardsRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ShowMyCardsRequestMessage::IsInitialized() const {

  return true;
}

void ShowMyCardsRequestMessage::Swap(ShowMyCardsRequestMessage* other) {
  if (other != this) {
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ShowMyCardsRequestMessage::GetTypeName() const {
  return "ShowMyCardsRequestMessage";
}


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

#ifndef _MSC_VER
const int AfterHandShowCardsMessage::kPlayerResultFieldNumber;
#endif  // !_MSC_VER

AfterHandShowCardsMessage::AfterHandShowCardsMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AfterHandShowCardsMessage)
}

void AfterHandShowCardsMessage::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  playerresult_ = const_cast< ::PlayerResult*>(
      ::PlayerResult::internal_default_instance());
#else
  playerresult_ = const_cast< ::PlayerResult*>(&::PlayerResult::default_instance());
#endif
}

AfterHandShowCardsMessage::AfterHandShowCardsMessage(const AfterHandShowCardsMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AfterHandShowCardsMessage)
}

void AfterHandShowCardsMessage::SharedCtor() {
  _cached_size_ = 0;
  playerresult_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AfterHandShowCardsMessage::~AfterHandShowCardsMessage() {
  // @@protoc_insertion_point(destructor:AfterHandShowCardsMessage)
  SharedDtor();
}

void AfterHandShowCardsMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete playerresult_;
  }
}

void AfterHandShowCardsMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AfterHandShowCardsMessage& AfterHandShowCardsMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AfterHandShowCardsMessage* AfterHandShowCardsMessage::default_instance_ = NULL;

AfterHandShowCardsMessage* AfterHandShowCardsMessage::New() const {
  return new AfterHandShowCardsMessage;
}

void AfterHandShowCardsMessage::Clear() {
  if (has_playerresult()) {
    if (playerresult_ != NULL) playerresult_->::PlayerResult::Clear();
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AfterHandShowCardsMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AfterHandShowCardsMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .PlayerResult playerResult = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_playerresult()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AfterHandShowCardsMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AfterHandShowCardsMessage)
  return false;
#undef DO_
}

void AfterHandShowCardsMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AfterHandShowCardsMessage)
  // required .PlayerResult playerResult = 1;
  if (has_playerresult()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->playerresult(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AfterHandShowCardsMessage)
}

int AfterHandShowCardsMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .PlayerResult playerResult = 1;
    if (has_playerresult()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->playerresult());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AfterHandShowCardsMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AfterHandShowCardsMessage*>(&from));
}

void AfterHandShowCardsMessage::MergeFrom(const AfterHandShowCardsMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_playerresult()) {
      mutable_playerresult()->::PlayerResult::MergeFrom(from.playerresult());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AfterHandShowCardsMessage::CopyFrom(const AfterHandShowCardsMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AfterHandShowCardsMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_playerresult()) {
    if (!this->playerresult().IsInitialized()) return false;
  }
  return true;
}

void AfterHandShowCardsMessage::Swap(AfterHandShowCardsMessage* other) {
  if (other != this) {
    std::swap(playerresult_, other->playerresult_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AfterHandShowCardsMessage::GetTypeName() const {
  return "AfterHandShowCardsMessage";
}


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

#ifndef _MSC_VER
const int EndOfGameMessage::kGameIdFieldNumber;
const int EndOfGameMessage::kWinnerPlayerIdFieldNumber;
#endif  // !_MSC_VER

EndOfGameMessage::EndOfGameMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:EndOfGameMessage)
}

void EndOfGameMessage::InitAsDefaultInstance() {
}

EndOfGameMessage::EndOfGameMessage(const EndOfGameMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:EndOfGameMessage)
}

void EndOfGameMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  winnerplayerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

EndOfGameMessage::~EndOfGameMessage() {
  // @@protoc_insertion_point(destructor:EndOfGameMessage)
  SharedDtor();
}

void EndOfGameMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void EndOfGameMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const EndOfGameMessage& EndOfGameMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

EndOfGameMessage* EndOfGameMessage::default_instance_ = NULL;

EndOfGameMessage* EndOfGameMessage::New() const {
  return new EndOfGameMessage;
}

void EndOfGameMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<EndOfGameMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, winnerplayerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool EndOfGameMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:EndOfGameMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_winnerPlayerId;
        break;
      }

      // required uint32 winnerPlayerId = 2;
      case 2: {
        if (tag == 16) {
         parse_winnerPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &winnerplayerid_)));
          set_has_winnerplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:EndOfGameMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:EndOfGameMessage)
  return false;
#undef DO_
}

void EndOfGameMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:EndOfGameMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 winnerPlayerId = 2;
  if (has_winnerplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->winnerplayerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:EndOfGameMessage)
}

int EndOfGameMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 winnerPlayerId = 2;
    if (has_winnerplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->winnerplayerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void EndOfGameMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const EndOfGameMessage*>(&from));
}

void EndOfGameMessage::MergeFrom(const EndOfGameMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_winnerplayerid()) {
      set_winnerplayerid(from.winnerplayerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void EndOfGameMessage::CopyFrom(const EndOfGameMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool EndOfGameMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void EndOfGameMessage::Swap(EndOfGameMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(winnerplayerid_, other->winnerplayerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string EndOfGameMessage::GetTypeName() const {
  return "EndOfGameMessage";
}


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

#ifndef _MSC_VER
const int PlayerIdChangedMessage::kOldPlayerIdFieldNumber;
const int PlayerIdChangedMessage::kNewPlayerIdFieldNumber;
#endif  // !_MSC_VER

PlayerIdChangedMessage::PlayerIdChangedMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PlayerIdChangedMessage)
}

void PlayerIdChangedMessage::InitAsDefaultInstance() {
}

PlayerIdChangedMessage::PlayerIdChangedMessage(const PlayerIdChangedMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PlayerIdChangedMessage)
}

void PlayerIdChangedMessage::SharedCtor() {
  _cached_size_ = 0;
  oldplayerid_ = 0u;
  newplayerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PlayerIdChangedMessage::~PlayerIdChangedMessage() {
  // @@protoc_insertion_point(destructor:PlayerIdChangedMessage)
  SharedDtor();
}

void PlayerIdChangedMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void PlayerIdChangedMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PlayerIdChangedMessage& PlayerIdChangedMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

PlayerIdChangedMessage* PlayerIdChangedMessage::default_instance_ = NULL;

PlayerIdChangedMessage* PlayerIdChangedMessage::New() const {
  return new PlayerIdChangedMessage;
}

void PlayerIdChangedMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<PlayerIdChangedMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(oldplayerid_, newplayerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PlayerIdChangedMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PlayerIdChangedMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 oldPlayerId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &oldplayerid_)));
          set_has_oldplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_newPlayerId;
        break;
      }

      // required uint32 newPlayerId = 2;
      case 2: {
        if (tag == 16) {
         parse_newPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &newplayerid_)));
          set_has_newplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PlayerIdChangedMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PlayerIdChangedMessage)
  return false;
#undef DO_
}

void PlayerIdChangedMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PlayerIdChangedMessage)
  // required uint32 oldPlayerId = 1;
  if (has_oldplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->oldplayerid(), output);
  }

  // required uint32 newPlayerId = 2;
  if (has_newplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->newplayerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PlayerIdChangedMessage)
}

int PlayerIdChangedMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 oldPlayerId = 1;
    if (has_oldplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->oldplayerid());
    }

    // required uint32 newPlayerId = 2;
    if (has_newplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->newplayerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PlayerIdChangedMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PlayerIdChangedMessage*>(&from));
}

void PlayerIdChangedMessage::MergeFrom(const PlayerIdChangedMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_oldplayerid()) {
      set_oldplayerid(from.oldplayerid());
    }
    if (from.has_newplayerid()) {
      set_newplayerid(from.newplayerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PlayerIdChangedMessage::CopyFrom(const PlayerIdChangedMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PlayerIdChangedMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void PlayerIdChangedMessage::Swap(PlayerIdChangedMessage* other) {
  if (other != this) {
    std::swap(oldplayerid_, other->oldplayerid_);
    std::swap(newplayerid_, other->newplayerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PlayerIdChangedMessage::GetTypeName() const {
  return "PlayerIdChangedMessage";
}


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

#ifndef _MSC_VER
const int AskKickPlayerMessage::kGameIdFieldNumber;
const int AskKickPlayerMessage::kPlayerIdFieldNumber;
#endif  // !_MSC_VER

AskKickPlayerMessage::AskKickPlayerMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AskKickPlayerMessage)
}

void AskKickPlayerMessage::InitAsDefaultInstance() {
}

AskKickPlayerMessage::AskKickPlayerMessage(const AskKickPlayerMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AskKickPlayerMessage)
}

void AskKickPlayerMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AskKickPlayerMessage::~AskKickPlayerMessage() {
  // @@protoc_insertion_point(destructor:AskKickPlayerMessage)
  SharedDtor();
}

void AskKickPlayerMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AskKickPlayerMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AskKickPlayerMessage& AskKickPlayerMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AskKickPlayerMessage* AskKickPlayerMessage::default_instance_ = NULL;

AskKickPlayerMessage* AskKickPlayerMessage::New() const {
  return new AskKickPlayerMessage;
}

void AskKickPlayerMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<AskKickPlayerMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, playerid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AskKickPlayerMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AskKickPlayerMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AskKickPlayerMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AskKickPlayerMessage)
  return false;
#undef DO_
}

void AskKickPlayerMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AskKickPlayerMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AskKickPlayerMessage)
}

int AskKickPlayerMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AskKickPlayerMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AskKickPlayerMessage*>(&from));
}

void AskKickPlayerMessage::MergeFrom(const AskKickPlayerMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AskKickPlayerMessage::CopyFrom(const AskKickPlayerMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AskKickPlayerMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void AskKickPlayerMessage::Swap(AskKickPlayerMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AskKickPlayerMessage::GetTypeName() const {
  return "AskKickPlayerMessage";
}


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

bool AskKickDeniedMessage_KickDeniedReason_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const AskKickDeniedMessage_KickDeniedReason AskKickDeniedMessage::kickDeniedInvalidGameState;
const AskKickDeniedMessage_KickDeniedReason AskKickDeniedMessage::kickDeniedNotPossible;
const AskKickDeniedMessage_KickDeniedReason AskKickDeniedMessage::kickDeniedTryAgainLater;
const AskKickDeniedMessage_KickDeniedReason AskKickDeniedMessage::kickDeniedAlreadyInProgress;
const AskKickDeniedMessage_KickDeniedReason AskKickDeniedMessage::kickDeniedInvalidPlayerId;
const AskKickDeniedMessage_KickDeniedReason AskKickDeniedMessage::KickDeniedReason_MIN;
const AskKickDeniedMessage_KickDeniedReason AskKickDeniedMessage::KickDeniedReason_MAX;
const int AskKickDeniedMessage::KickDeniedReason_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int AskKickDeniedMessage::kGameIdFieldNumber;
const int AskKickDeniedMessage::kPlayerIdFieldNumber;
const int AskKickDeniedMessage::kKickDeniedReasonFieldNumber;
#endif  // !_MSC_VER

AskKickDeniedMessage::AskKickDeniedMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AskKickDeniedMessage)
}

void AskKickDeniedMessage::InitAsDefaultInstance() {
}

AskKickDeniedMessage::AskKickDeniedMessage(const AskKickDeniedMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AskKickDeniedMessage)
}

void AskKickDeniedMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  kickdeniedreason_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AskKickDeniedMessage::~AskKickDeniedMessage() {
  // @@protoc_insertion_point(destructor:AskKickDeniedMessage)
  SharedDtor();
}

void AskKickDeniedMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AskKickDeniedMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AskKickDeniedMessage& AskKickDeniedMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AskKickDeniedMessage* AskKickDeniedMessage::default_instance_ = NULL;

AskKickDeniedMessage* AskKickDeniedMessage::New() const {
  return new AskKickDeniedMessage;
}

void AskKickDeniedMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<AskKickDeniedMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, kickdeniedreason_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AskKickDeniedMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AskKickDeniedMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_kickDeniedReason;
        break;
      }

      // required .AskKickDeniedMessage.KickDeniedReason kickDeniedReason = 3;
      case 3: {
        if (tag == 24) {
         parse_kickDeniedReason:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::AskKickDeniedMessage_KickDeniedReason_IsValid(value)) {
            set_kickdeniedreason(static_cast< ::AskKickDeniedMessage_KickDeniedReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AskKickDeniedMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AskKickDeniedMessage)
  return false;
#undef DO_
}

void AskKickDeniedMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AskKickDeniedMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  // required .AskKickDeniedMessage.KickDeniedReason kickDeniedReason = 3;
  if (has_kickdeniedreason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->kickdeniedreason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AskKickDeniedMessage)
}

int AskKickDeniedMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required .AskKickDeniedMessage.KickDeniedReason kickDeniedReason = 3;
    if (has_kickdeniedreason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->kickdeniedreason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AskKickDeniedMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AskKickDeniedMessage*>(&from));
}

void AskKickDeniedMessage::MergeFrom(const AskKickDeniedMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_kickdeniedreason()) {
      set_kickdeniedreason(from.kickdeniedreason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AskKickDeniedMessage::CopyFrom(const AskKickDeniedMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AskKickDeniedMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void AskKickDeniedMessage::Swap(AskKickDeniedMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(kickdeniedreason_, other->kickdeniedreason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AskKickDeniedMessage::GetTypeName() const {
  return "AskKickDeniedMessage";
}


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

#ifndef _MSC_VER
const int StartKickPetitionMessage::kGameIdFieldNumber;
const int StartKickPetitionMessage::kPetitionIdFieldNumber;
const int StartKickPetitionMessage::kProposingPlayerIdFieldNumber;
const int StartKickPetitionMessage::kKickPlayerIdFieldNumber;
const int StartKickPetitionMessage::kKickTimeoutSecFieldNumber;
const int StartKickPetitionMessage::kNumVotesNeededToKickFieldNumber;
#endif  // !_MSC_VER

StartKickPetitionMessage::StartKickPetitionMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:StartKickPetitionMessage)
}

void StartKickPetitionMessage::InitAsDefaultInstance() {
}

StartKickPetitionMessage::StartKickPetitionMessage(const StartKickPetitionMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:StartKickPetitionMessage)
}

void StartKickPetitionMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  petitionid_ = 0u;
  proposingplayerid_ = 0u;
  kickplayerid_ = 0u;
  kicktimeoutsec_ = 0u;
  numvotesneededtokick_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StartKickPetitionMessage::~StartKickPetitionMessage() {
  // @@protoc_insertion_point(destructor:StartKickPetitionMessage)
  SharedDtor();
}

void StartKickPetitionMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void StartKickPetitionMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const StartKickPetitionMessage& StartKickPetitionMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

StartKickPetitionMessage* StartKickPetitionMessage::default_instance_ = NULL;

StartKickPetitionMessage* StartKickPetitionMessage::New() const {
  return new StartKickPetitionMessage;
}

void StartKickPetitionMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<StartKickPetitionMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 63) {
    ZR_(gameid_, numvotesneededtokick_);
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool StartKickPetitionMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:StartKickPetitionMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_petitionId;
        break;
      }

      // required uint32 petitionId = 2;
      case 2: {
        if (tag == 16) {
         parse_petitionId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &petitionid_)));
          set_has_petitionid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_proposingPlayerId;
        break;
      }

      // required uint32 proposingPlayerId = 3;
      case 3: {
        if (tag == 24) {
         parse_proposingPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &proposingplayerid_)));
          set_has_proposingplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_kickPlayerId;
        break;
      }

      // required uint32 kickPlayerId = 4;
      case 4: {
        if (tag == 32) {
         parse_kickPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &kickplayerid_)));
          set_has_kickplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_kickTimeoutSec;
        break;
      }

      // required uint32 kickTimeoutSec = 5;
      case 5: {
        if (tag == 40) {
         parse_kickTimeoutSec:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &kicktimeoutsec_)));
          set_has_kicktimeoutsec();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_numVotesNeededToKick;
        break;
      }

      // required uint32 numVotesNeededToKick = 6;
      case 6: {
        if (tag == 48) {
         parse_numVotesNeededToKick:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &numvotesneededtokick_)));
          set_has_numvotesneededtokick();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:StartKickPetitionMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:StartKickPetitionMessage)
  return false;
#undef DO_
}

void StartKickPetitionMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:StartKickPetitionMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 petitionId = 2;
  if (has_petitionid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->petitionid(), output);
  }

  // required uint32 proposingPlayerId = 3;
  if (has_proposingplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->proposingplayerid(), output);
  }

  // required uint32 kickPlayerId = 4;
  if (has_kickplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->kickplayerid(), output);
  }

  // required uint32 kickTimeoutSec = 5;
  if (has_kicktimeoutsec()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->kicktimeoutsec(), output);
  }

  // required uint32 numVotesNeededToKick = 6;
  if (has_numvotesneededtokick()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->numvotesneededtokick(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:StartKickPetitionMessage)
}

int StartKickPetitionMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 petitionId = 2;
    if (has_petitionid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->petitionid());
    }

    // required uint32 proposingPlayerId = 3;
    if (has_proposingplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->proposingplayerid());
    }

    // required uint32 kickPlayerId = 4;
    if (has_kickplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->kickplayerid());
    }

    // required uint32 kickTimeoutSec = 5;
    if (has_kicktimeoutsec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->kicktimeoutsec());
    }

    // required uint32 numVotesNeededToKick = 6;
    if (has_numvotesneededtokick()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->numvotesneededtokick());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StartKickPetitionMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const StartKickPetitionMessage*>(&from));
}

void StartKickPetitionMessage::MergeFrom(const StartKickPetitionMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_petitionid()) {
      set_petitionid(from.petitionid());
    }
    if (from.has_proposingplayerid()) {
      set_proposingplayerid(from.proposingplayerid());
    }
    if (from.has_kickplayerid()) {
      set_kickplayerid(from.kickplayerid());
    }
    if (from.has_kicktimeoutsec()) {
      set_kicktimeoutsec(from.kicktimeoutsec());
    }
    if (from.has_numvotesneededtokick()) {
      set_numvotesneededtokick(from.numvotesneededtokick());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void StartKickPetitionMessage::CopyFrom(const StartKickPetitionMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StartKickPetitionMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;

  return true;
}

void StartKickPetitionMessage::Swap(StartKickPetitionMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(petitionid_, other->petitionid_);
    std::swap(proposingplayerid_, other->proposingplayerid_);
    std::swap(kickplayerid_, other->kickplayerid_);
    std::swap(kicktimeoutsec_, other->kicktimeoutsec_);
    std::swap(numvotesneededtokick_, other->numvotesneededtokick_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string StartKickPetitionMessage::GetTypeName() const {
  return "StartKickPetitionMessage";
}


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

#ifndef _MSC_VER
const int VoteKickRequestMessage::kGameIdFieldNumber;
const int VoteKickRequestMessage::kPetitionIdFieldNumber;
const int VoteKickRequestMessage::kVoteKickFieldNumber;
#endif  // !_MSC_VER

VoteKickRequestMessage::VoteKickRequestMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:VoteKickRequestMessage)
}

void VoteKickRequestMessage::InitAsDefaultInstance() {
}

VoteKickRequestMessage::VoteKickRequestMessage(const VoteKickRequestMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:VoteKickRequestMessage)
}

void VoteKickRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  petitionid_ = 0u;
  votekick_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

VoteKickRequestMessage::~VoteKickRequestMessage() {
  // @@protoc_insertion_point(destructor:VoteKickRequestMessage)
  SharedDtor();
}

void VoteKickRequestMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void VoteKickRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const VoteKickRequestMessage& VoteKickRequestMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

VoteKickRequestMessage* VoteKickRequestMessage::default_instance_ = NULL;

VoteKickRequestMessage* VoteKickRequestMessage::New() const {
  return new VoteKickRequestMessage;
}

void VoteKickRequestMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<VoteKickRequestMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, votekick_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool VoteKickRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:VoteKickRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_petitionId;
        break;
      }

      // required uint32 petitionId = 2;
      case 2: {
        if (tag == 16) {
         parse_petitionId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &petitionid_)));
          set_has_petitionid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_voteKick;
        break;
      }

      // required bool voteKick = 3;
      case 3: {
        if (tag == 24) {
         parse_voteKick:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &votekick_)));
          set_has_votekick();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:VoteKickRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:VoteKickRequestMessage)
  return false;
#undef DO_
}

void VoteKickRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:VoteKickRequestMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 petitionId = 2;
  if (has_petitionid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->petitionid(), output);
  }

  // required bool voteKick = 3;
  if (has_votekick()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->votekick(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:VoteKickRequestMessage)
}

int VoteKickRequestMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 petitionId = 2;
    if (has_petitionid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->petitionid());
    }

    // required bool voteKick = 3;
    if (has_votekick()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void VoteKickRequestMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const VoteKickRequestMessage*>(&from));
}

void VoteKickRequestMessage::MergeFrom(const VoteKickRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_petitionid()) {
      set_petitionid(from.petitionid());
    }
    if (from.has_votekick()) {
      set_votekick(from.votekick());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void VoteKickRequestMessage::CopyFrom(const VoteKickRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool VoteKickRequestMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void VoteKickRequestMessage::Swap(VoteKickRequestMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(petitionid_, other->petitionid_);
    std::swap(votekick_, other->votekick_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string VoteKickRequestMessage::GetTypeName() const {
  return "VoteKickRequestMessage";
}


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

bool VoteKickReplyMessage_VoteKickReplyType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const VoteKickReplyMessage_VoteKickReplyType VoteKickReplyMessage::voteKickAck;
const VoteKickReplyMessage_VoteKickReplyType VoteKickReplyMessage::voteKickDeniedInvalid;
const VoteKickReplyMessage_VoteKickReplyType VoteKickReplyMessage::voteKickDeniedAlreadyVoted;
const VoteKickReplyMessage_VoteKickReplyType VoteKickReplyMessage::VoteKickReplyType_MIN;
const VoteKickReplyMessage_VoteKickReplyType VoteKickReplyMessage::VoteKickReplyType_MAX;
const int VoteKickReplyMessage::VoteKickReplyType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int VoteKickReplyMessage::kGameIdFieldNumber;
const int VoteKickReplyMessage::kPetitionIdFieldNumber;
const int VoteKickReplyMessage::kVoteKickReplyTypeFieldNumber;
#endif  // !_MSC_VER

VoteKickReplyMessage::VoteKickReplyMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:VoteKickReplyMessage)
}

void VoteKickReplyMessage::InitAsDefaultInstance() {
}

VoteKickReplyMessage::VoteKickReplyMessage(const VoteKickReplyMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:VoteKickReplyMessage)
}

void VoteKickReplyMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  petitionid_ = 0u;
  votekickreplytype_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

VoteKickReplyMessage::~VoteKickReplyMessage() {
  // @@protoc_insertion_point(destructor:VoteKickReplyMessage)
  SharedDtor();
}

void VoteKickReplyMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void VoteKickReplyMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const VoteKickReplyMessage& VoteKickReplyMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

VoteKickReplyMessage* VoteKickReplyMessage::default_instance_ = NULL;

VoteKickReplyMessage* VoteKickReplyMessage::New() const {
  return new VoteKickReplyMessage;
}

void VoteKickReplyMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<VoteKickReplyMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(gameid_, votekickreplytype_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool VoteKickReplyMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:VoteKickReplyMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_petitionId;
        break;
      }

      // required uint32 petitionId = 2;
      case 2: {
        if (tag == 16) {
         parse_petitionId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &petitionid_)));
          set_has_petitionid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_voteKickReplyType;
        break;
      }

      // required .VoteKickReplyMessage.VoteKickReplyType voteKickReplyType = 3;
      case 3: {
        if (tag == 24) {
         parse_voteKickReplyType:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::VoteKickReplyMessage_VoteKickReplyType_IsValid(value)) {
            set_votekickreplytype(static_cast< ::VoteKickReplyMessage_VoteKickReplyType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:VoteKickReplyMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:VoteKickReplyMessage)
  return false;
#undef DO_
}

void VoteKickReplyMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:VoteKickReplyMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 petitionId = 2;
  if (has_petitionid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->petitionid(), output);
  }

  // required .VoteKickReplyMessage.VoteKickReplyType voteKickReplyType = 3;
  if (has_votekickreplytype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->votekickreplytype(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:VoteKickReplyMessage)
}

int VoteKickReplyMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 petitionId = 2;
    if (has_petitionid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->petitionid());
    }

    // required .VoteKickReplyMessage.VoteKickReplyType voteKickReplyType = 3;
    if (has_votekickreplytype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->votekickreplytype());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void VoteKickReplyMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const VoteKickReplyMessage*>(&from));
}

void VoteKickReplyMessage::MergeFrom(const VoteKickReplyMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_petitionid()) {
      set_petitionid(from.petitionid());
    }
    if (from.has_votekickreplytype()) {
      set_votekickreplytype(from.votekickreplytype());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void VoteKickReplyMessage::CopyFrom(const VoteKickReplyMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool VoteKickReplyMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;

  return true;
}

void VoteKickReplyMessage::Swap(VoteKickReplyMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(petitionid_, other->petitionid_);
    std::swap(votekickreplytype_, other->votekickreplytype_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string VoteKickReplyMessage::GetTypeName() const {
  return "VoteKickReplyMessage";
}


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

#ifndef _MSC_VER
const int KickPetitionUpdateMessage::kGameIdFieldNumber;
const int KickPetitionUpdateMessage::kPetitionIdFieldNumber;
const int KickPetitionUpdateMessage::kNumVotesAgainstKickingFieldNumber;
const int KickPetitionUpdateMessage::kNumVotesInFavourOfKickingFieldNumber;
const int KickPetitionUpdateMessage::kNumVotesNeededToKickFieldNumber;
#endif  // !_MSC_VER

KickPetitionUpdateMessage::KickPetitionUpdateMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:KickPetitionUpdateMessage)
}

void KickPetitionUpdateMessage::InitAsDefaultInstance() {
}

KickPetitionUpdateMessage::KickPetitionUpdateMessage(const KickPetitionUpdateMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:KickPetitionUpdateMessage)
}

void KickPetitionUpdateMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  petitionid_ = 0u;
  numvotesagainstkicking_ = 0u;
  numvotesinfavourofkicking_ = 0u;
  numvotesneededtokick_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

KickPetitionUpdateMessage::~KickPetitionUpdateMessage() {
  // @@protoc_insertion_point(destructor:KickPetitionUpdateMessage)
  SharedDtor();
}

void KickPetitionUpdateMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void KickPetitionUpdateMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const KickPetitionUpdateMessage& KickPetitionUpdateMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

KickPetitionUpdateMessage* KickPetitionUpdateMessage::default_instance_ = NULL;

KickPetitionUpdateMessage* KickPetitionUpdateMessage::New() const {
  return new KickPetitionUpdateMessage;
}

void KickPetitionUpdateMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<KickPetitionUpdateMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 31) {
    ZR_(gameid_, numvotesneededtokick_);
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool KickPetitionUpdateMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:KickPetitionUpdateMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_petitionId;
        break;
      }

      // required uint32 petitionId = 2;
      case 2: {
        if (tag == 16) {
         parse_petitionId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &petitionid_)));
          set_has_petitionid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_numVotesAgainstKicking;
        break;
      }

      // required uint32 numVotesAgainstKicking = 3;
      case 3: {
        if (tag == 24) {
         parse_numVotesAgainstKicking:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &numvotesagainstkicking_)));
          set_has_numvotesagainstkicking();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_numVotesInFavourOfKicking;
        break;
      }

      // required uint32 numVotesInFavourOfKicking = 4;
      case 4: {
        if (tag == 32) {
         parse_numVotesInFavourOfKicking:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &numvotesinfavourofkicking_)));
          set_has_numvotesinfavourofkicking();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_numVotesNeededToKick;
        break;
      }

      // required uint32 numVotesNeededToKick = 5;
      case 5: {
        if (tag == 40) {
         parse_numVotesNeededToKick:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &numvotesneededtokick_)));
          set_has_numvotesneededtokick();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:KickPetitionUpdateMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:KickPetitionUpdateMessage)
  return false;
#undef DO_
}

void KickPetitionUpdateMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:KickPetitionUpdateMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 petitionId = 2;
  if (has_petitionid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->petitionid(), output);
  }

  // required uint32 numVotesAgainstKicking = 3;
  if (has_numvotesagainstkicking()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->numvotesagainstkicking(), output);
  }

  // required uint32 numVotesInFavourOfKicking = 4;
  if (has_numvotesinfavourofkicking()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->numvotesinfavourofkicking(), output);
  }

  // required uint32 numVotesNeededToKick = 5;
  if (has_numvotesneededtokick()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->numvotesneededtokick(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:KickPetitionUpdateMessage)
}

int KickPetitionUpdateMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 petitionId = 2;
    if (has_petitionid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->petitionid());
    }

    // required uint32 numVotesAgainstKicking = 3;
    if (has_numvotesagainstkicking()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->numvotesagainstkicking());
    }

    // required uint32 numVotesInFavourOfKicking = 4;
    if (has_numvotesinfavourofkicking()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->numvotesinfavourofkicking());
    }

    // required uint32 numVotesNeededToKick = 5;
    if (has_numvotesneededtokick()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->numvotesneededtokick());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void KickPetitionUpdateMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const KickPetitionUpdateMessage*>(&from));
}

void KickPetitionUpdateMessage::MergeFrom(const KickPetitionUpdateMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_petitionid()) {
      set_petitionid(from.petitionid());
    }
    if (from.has_numvotesagainstkicking()) {
      set_numvotesagainstkicking(from.numvotesagainstkicking());
    }
    if (from.has_numvotesinfavourofkicking()) {
      set_numvotesinfavourofkicking(from.numvotesinfavourofkicking());
    }
    if (from.has_numvotesneededtokick()) {
      set_numvotesneededtokick(from.numvotesneededtokick());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void KickPetitionUpdateMessage::CopyFrom(const KickPetitionUpdateMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool KickPetitionUpdateMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;

  return true;
}

void KickPetitionUpdateMessage::Swap(KickPetitionUpdateMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(petitionid_, other->petitionid_);
    std::swap(numvotesagainstkicking_, other->numvotesagainstkicking_);
    std::swap(numvotesinfavourofkicking_, other->numvotesinfavourofkicking_);
    std::swap(numvotesneededtokick_, other->numvotesneededtokick_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string KickPetitionUpdateMessage::GetTypeName() const {
  return "KickPetitionUpdateMessage";
}


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

bool EndKickPetitionMessage_PetitionEndReason_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const EndKickPetitionMessage_PetitionEndReason EndKickPetitionMessage::petitionEndEnoughVotes;
const EndKickPetitionMessage_PetitionEndReason EndKickPetitionMessage::petitionEndTooFewPlayers;
const EndKickPetitionMessage_PetitionEndReason EndKickPetitionMessage::petitionEndPlayerLeft;
const EndKickPetitionMessage_PetitionEndReason EndKickPetitionMessage::petitionEndTimeout;
const EndKickPetitionMessage_PetitionEndReason EndKickPetitionMessage::PetitionEndReason_MIN;
const EndKickPetitionMessage_PetitionEndReason EndKickPetitionMessage::PetitionEndReason_MAX;
const int EndKickPetitionMessage::PetitionEndReason_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int EndKickPetitionMessage::kGameIdFieldNumber;
const int EndKickPetitionMessage::kPetitionIdFieldNumber;
const int EndKickPetitionMessage::kNumVotesAgainstKickingFieldNumber;
const int EndKickPetitionMessage::kNumVotesInFavourOfKickingFieldNumber;
const int EndKickPetitionMessage::kResultPlayerKickedFieldNumber;
const int EndKickPetitionMessage::kPetitionEndReasonFieldNumber;
#endif  // !_MSC_VER

EndKickPetitionMessage::EndKickPetitionMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:EndKickPetitionMessage)
}

void EndKickPetitionMessage::InitAsDefaultInstance() {
}

EndKickPetitionMessage::EndKickPetitionMessage(const EndKickPetitionMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:EndKickPetitionMessage)
}

void EndKickPetitionMessage::SharedCtor() {
  _cached_size_ = 0;
  gameid_ = 0u;
  petitionid_ = 0u;
  numvotesagainstkicking_ = 0u;
  numvotesinfavourofkicking_ = 0u;
  resultplayerkicked_ = 0u;
  petitionendreason_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

EndKickPetitionMessage::~EndKickPetitionMessage() {
  // @@protoc_insertion_point(destructor:EndKickPetitionMessage)
  SharedDtor();
}

void EndKickPetitionMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void EndKickPetitionMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const EndKickPetitionMessage& EndKickPetitionMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

EndKickPetitionMessage* EndKickPetitionMessage::default_instance_ = NULL;

EndKickPetitionMessage* EndKickPetitionMessage::New() const {
  return new EndKickPetitionMessage;
}

void EndKickPetitionMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<EndKickPetitionMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 63) {
    ZR_(gameid_, petitionendreason_);
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool EndKickPetitionMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:EndKickPetitionMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_petitionId;
        break;
      }

      // required uint32 petitionId = 2;
      case 2: {
        if (tag == 16) {
         parse_petitionId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &petitionid_)));
          set_has_petitionid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_numVotesAgainstKicking;
        break;
      }

      // required uint32 numVotesAgainstKicking = 3;
      case 3: {
        if (tag == 24) {
         parse_numVotesAgainstKicking:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &numvotesagainstkicking_)));
          set_has_numvotesagainstkicking();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_numVotesInFavourOfKicking;
        break;
      }

      // required uint32 numVotesInFavourOfKicking = 4;
      case 4: {
        if (tag == 32) {
         parse_numVotesInFavourOfKicking:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &numvotesinfavourofkicking_)));
          set_has_numvotesinfavourofkicking();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_resultPlayerKicked;
        break;
      }

      // required uint32 resultPlayerKicked = 5;
      case 5: {
        if (tag == 40) {
         parse_resultPlayerKicked:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &resultplayerkicked_)));
          set_has_resultplayerkicked();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_petitionEndReason;
        break;
      }

      // required .EndKickPetitionMessage.PetitionEndReason petitionEndReason = 6;
      case 6: {
        if (tag == 48) {
         parse_petitionEndReason:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::EndKickPetitionMessage_PetitionEndReason_IsValid(value)) {
            set_petitionendreason(static_cast< ::EndKickPetitionMessage_PetitionEndReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:EndKickPetitionMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:EndKickPetitionMessage)
  return false;
#undef DO_
}

void EndKickPetitionMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:EndKickPetitionMessage)
  // required uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // required uint32 petitionId = 2;
  if (has_petitionid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->petitionid(), output);
  }

  // required uint32 numVotesAgainstKicking = 3;
  if (has_numvotesagainstkicking()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->numvotesagainstkicking(), output);
  }

  // required uint32 numVotesInFavourOfKicking = 4;
  if (has_numvotesinfavourofkicking()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->numvotesinfavourofkicking(), output);
  }

  // required uint32 resultPlayerKicked = 5;
  if (has_resultplayerkicked()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->resultplayerkicked(), output);
  }

  // required .EndKickPetitionMessage.PetitionEndReason petitionEndReason = 6;
  if (has_petitionendreason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      6, this->petitionendreason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:EndKickPetitionMessage)
}

int EndKickPetitionMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 petitionId = 2;
    if (has_petitionid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->petitionid());
    }

    // required uint32 numVotesAgainstKicking = 3;
    if (has_numvotesagainstkicking()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->numvotesagainstkicking());
    }

    // required uint32 numVotesInFavourOfKicking = 4;
    if (has_numvotesinfavourofkicking()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->numvotesinfavourofkicking());
    }

    // required uint32 resultPlayerKicked = 5;
    if (has_resultplayerkicked()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->resultplayerkicked());
    }

    // required .EndKickPetitionMessage.PetitionEndReason petitionEndReason = 6;
    if (has_petitionendreason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->petitionendreason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void EndKickPetitionMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const EndKickPetitionMessage*>(&from));
}

void EndKickPetitionMessage::MergeFrom(const EndKickPetitionMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_petitionid()) {
      set_petitionid(from.petitionid());
    }
    if (from.has_numvotesagainstkicking()) {
      set_numvotesagainstkicking(from.numvotesagainstkicking());
    }
    if (from.has_numvotesinfavourofkicking()) {
      set_numvotesinfavourofkicking(from.numvotesinfavourofkicking());
    }
    if (from.has_resultplayerkicked()) {
      set_resultplayerkicked(from.resultplayerkicked());
    }
    if (from.has_petitionendreason()) {
      set_petitionendreason(from.petitionendreason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void EndKickPetitionMessage::CopyFrom(const EndKickPetitionMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool EndKickPetitionMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;

  return true;
}

void EndKickPetitionMessage::Swap(EndKickPetitionMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(petitionid_, other->petitionid_);
    std::swap(numvotesagainstkicking_, other->numvotesagainstkicking_);
    std::swap(numvotesinfavourofkicking_, other->numvotesinfavourofkicking_);
    std::swap(resultplayerkicked_, other->resultplayerkicked_);
    std::swap(petitionendreason_, other->petitionendreason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string EndKickPetitionMessage::GetTypeName() const {
  return "EndKickPetitionMessage";
}


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

bool StatisticsMessage_StatisticsData_StatisticsType_IsValid(int value) {
  switch(value) {
    case 1:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const StatisticsMessage_StatisticsData_StatisticsType StatisticsMessage_StatisticsData::statNumberOfPlayers;
const StatisticsMessage_StatisticsData_StatisticsType StatisticsMessage_StatisticsData::StatisticsType_MIN;
const StatisticsMessage_StatisticsData_StatisticsType StatisticsMessage_StatisticsData::StatisticsType_MAX;
const int StatisticsMessage_StatisticsData::StatisticsType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int StatisticsMessage_StatisticsData::kStatisticsTypeFieldNumber;
const int StatisticsMessage_StatisticsData::kStatisticsValueFieldNumber;
#endif  // !_MSC_VER

StatisticsMessage_StatisticsData::StatisticsMessage_StatisticsData()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:StatisticsMessage.StatisticsData)
}

void StatisticsMessage_StatisticsData::InitAsDefaultInstance() {
}

StatisticsMessage_StatisticsData::StatisticsMessage_StatisticsData(const StatisticsMessage_StatisticsData& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:StatisticsMessage.StatisticsData)
}

void StatisticsMessage_StatisticsData::SharedCtor() {
  _cached_size_ = 0;
  statisticstype_ = 1;
  statisticsvalue_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StatisticsMessage_StatisticsData::~StatisticsMessage_StatisticsData() {
  // @@protoc_insertion_point(destructor:StatisticsMessage.StatisticsData)
  SharedDtor();
}

void StatisticsMessage_StatisticsData::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void StatisticsMessage_StatisticsData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const StatisticsMessage_StatisticsData& StatisticsMessage_StatisticsData::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

StatisticsMessage_StatisticsData* StatisticsMessage_StatisticsData::default_instance_ = NULL;

StatisticsMessage_StatisticsData* StatisticsMessage_StatisticsData::New() const {
  return new StatisticsMessage_StatisticsData;
}

void StatisticsMessage_StatisticsData::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    statisticstype_ = 1;
    statisticsvalue_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool StatisticsMessage_StatisticsData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:StatisticsMessage.StatisticsData)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .StatisticsMessage.StatisticsData.StatisticsType statisticsType = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::StatisticsMessage_StatisticsData_StatisticsType_IsValid(value)) {
            set_statisticstype(static_cast< ::StatisticsMessage_StatisticsData_StatisticsType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_statisticsValue;
        break;
      }

      // required uint32 statisticsValue = 2;
      case 2: {
        if (tag == 16) {
         parse_statisticsValue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &statisticsvalue_)));
          set_has_statisticsvalue();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:StatisticsMessage.StatisticsData)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:StatisticsMessage.StatisticsData)
  return false;
#undef DO_
}

void StatisticsMessage_StatisticsData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:StatisticsMessage.StatisticsData)
  // required .StatisticsMessage.StatisticsData.StatisticsType statisticsType = 1;
  if (has_statisticstype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->statisticstype(), output);
  }

  // required uint32 statisticsValue = 2;
  if (has_statisticsvalue()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->statisticsvalue(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:StatisticsMessage.StatisticsData)
}

int StatisticsMessage_StatisticsData::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .StatisticsMessage.StatisticsData.StatisticsType statisticsType = 1;
    if (has_statisticstype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->statisticstype());
    }

    // required uint32 statisticsValue = 2;
    if (has_statisticsvalue()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->statisticsvalue());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StatisticsMessage_StatisticsData::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const StatisticsMessage_StatisticsData*>(&from));
}

void StatisticsMessage_StatisticsData::MergeFrom(const StatisticsMessage_StatisticsData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_statisticstype()) {
      set_statisticstype(from.statisticstype());
    }
    if (from.has_statisticsvalue()) {
      set_statisticsvalue(from.statisticsvalue());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void StatisticsMessage_StatisticsData::CopyFrom(const StatisticsMessage_StatisticsData& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StatisticsMessage_StatisticsData::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void StatisticsMessage_StatisticsData::Swap(StatisticsMessage_StatisticsData* other) {
  if (other != this) {
    std::swap(statisticstype_, other->statisticstype_);
    std::swap(statisticsvalue_, other->statisticsvalue_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string StatisticsMessage_StatisticsData::GetTypeName() const {
  return "StatisticsMessage.StatisticsData";
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int StatisticsMessage::kStatisticsDataFieldNumber;
#endif  // !_MSC_VER

StatisticsMessage::StatisticsMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:StatisticsMessage)
}

void StatisticsMessage::InitAsDefaultInstance() {
}

StatisticsMessage::StatisticsMessage(const StatisticsMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:StatisticsMessage)
}

void StatisticsMessage::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

StatisticsMessage::~StatisticsMessage() {
  // @@protoc_insertion_point(destructor:StatisticsMessage)
  SharedDtor();
}

void StatisticsMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void StatisticsMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const StatisticsMessage& StatisticsMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

StatisticsMessage* StatisticsMessage::default_instance_ = NULL;

StatisticsMessage* StatisticsMessage::New() const {
  return new StatisticsMessage;
}

void StatisticsMessage::Clear() {
  statisticsdata_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool StatisticsMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:StatisticsMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .StatisticsMessage.StatisticsData statisticsData = 1;
      case 1: {
        if (tag == 10) {
         parse_statisticsData:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_statisticsdata()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_statisticsData;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:StatisticsMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:StatisticsMessage)
  return false;
#undef DO_
}

void StatisticsMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:StatisticsMessage)
  // repeated .StatisticsMessage.StatisticsData statisticsData = 1;
  for (int i = 0; i < this->statisticsdata_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->statisticsdata(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:StatisticsMessage)
}

int StatisticsMessage::ByteSize() const {
  int total_size = 0;

  // repeated .StatisticsMessage.StatisticsData statisticsData = 1;
  total_size += 1 * this->statisticsdata_size();
  for (int i = 0; i < this->statisticsdata_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->statisticsdata(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void StatisticsMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const StatisticsMessage*>(&from));
}

void StatisticsMessage::MergeFrom(const StatisticsMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  statisticsdata_.MergeFrom(from.statisticsdata_);
  mutable_unknown_fields()->append(from.unknown_fields());
}

void StatisticsMessage::CopyFrom(const StatisticsMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StatisticsMessage::IsInitialized() const {

  if (!::google::protobuf::internal::AllAreInitialized(this->statisticsdata())) return false;
  return true;
}

void StatisticsMessage::Swap(StatisticsMessage* other) {
  if (other != this) {
    statisticsdata_.Swap(&other->statisticsdata_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string StatisticsMessage::GetTypeName() const {
  return "StatisticsMessage";
}


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

#ifndef _MSC_VER
const int ChatRequestMessage::kTargetGameIdFieldNumber;
const int ChatRequestMessage::kTargetPlayerIdFieldNumber;
const int ChatRequestMessage::kChatTextFieldNumber;
#endif  // !_MSC_VER

ChatRequestMessage::ChatRequestMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ChatRequestMessage)
}

void ChatRequestMessage::InitAsDefaultInstance() {
}

ChatRequestMessage::ChatRequestMessage(const ChatRequestMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ChatRequestMessage)
}

void ChatRequestMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  targetgameid_ = 0u;
  targetplayerid_ = 0u;
  chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ChatRequestMessage::~ChatRequestMessage() {
  // @@protoc_insertion_point(destructor:ChatRequestMessage)
  SharedDtor();
}

void ChatRequestMessage::SharedDtor() {
  if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete chattext_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ChatRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ChatRequestMessage& ChatRequestMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

ChatRequestMessage* ChatRequestMessage::default_instance_ = NULL;

ChatRequestMessage* ChatRequestMessage::New() const {
  return new ChatRequestMessage;
}

void ChatRequestMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ChatRequestMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 7) {
    ZR_(targetgameid_, targetplayerid_);
    if (has_chattext()) {
      if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        chattext_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ChatRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ChatRequestMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 targetGameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &targetgameid_)));
          set_has_targetgameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_targetPlayerId;
        break;
      }

      // optional uint32 targetPlayerId = 2;
      case 2: {
        if (tag == 16) {
         parse_targetPlayerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &targetplayerid_)));
          set_has_targetplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_chatText;
        break;
      }

      // required string chatText = 3;
      case 3: {
        if (tag == 26) {
         parse_chatText:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_chattext()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ChatRequestMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ChatRequestMessage)
  return false;
#undef DO_
}

void ChatRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ChatRequestMessage)
  // optional uint32 targetGameId = 1;
  if (has_targetgameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->targetgameid(), output);
  }

  // optional uint32 targetPlayerId = 2;
  if (has_targetplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->targetplayerid(), output);
  }

  // required string chatText = 3;
  if (has_chattext()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->chattext(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ChatRequestMessage)
}

int ChatRequestMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional uint32 targetGameId = 1;
    if (has_targetgameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->targetgameid());
    }

    // optional uint32 targetPlayerId = 2;
    if (has_targetplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->targetplayerid());
    }

    // required string chatText = 3;
    if (has_chattext()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->chattext());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ChatRequestMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ChatRequestMessage*>(&from));
}

void ChatRequestMessage::MergeFrom(const ChatRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_targetgameid()) {
      set_targetgameid(from.targetgameid());
    }
    if (from.has_targetplayerid()) {
      set_targetplayerid(from.targetplayerid());
    }
    if (from.has_chattext()) {
      set_chattext(from.chattext());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ChatRequestMessage::CopyFrom(const ChatRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ChatRequestMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false;

  return true;
}

void ChatRequestMessage::Swap(ChatRequestMessage* other) {
  if (other != this) {
    std::swap(targetgameid_, other->targetgameid_);
    std::swap(targetplayerid_, other->targetplayerid_);
    std::swap(chattext_, other->chattext_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ChatRequestMessage::GetTypeName() const {
  return "ChatRequestMessage";
}


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

bool ChatMessage_ChatType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const ChatMessage_ChatType ChatMessage::chatTypeLobby;
const ChatMessage_ChatType ChatMessage::chatTypeGame;
const ChatMessage_ChatType ChatMessage::chatTypeBot;
const ChatMessage_ChatType ChatMessage::chatTypeBroadcast;
const ChatMessage_ChatType ChatMessage::chatTypePrivate;
const ChatMessage_ChatType ChatMessage::ChatType_MIN;
const ChatMessage_ChatType ChatMessage::ChatType_MAX;
const int ChatMessage::ChatType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int ChatMessage::kGameIdFieldNumber;
const int ChatMessage::kPlayerIdFieldNumber;
const int ChatMessage::kChatTypeFieldNumber;
const int ChatMessage::kChatTextFieldNumber;
#endif  // !_MSC_VER

ChatMessage::ChatMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ChatMessage)
}

void ChatMessage::InitAsDefaultInstance() {
}

ChatMessage::ChatMessage(const ChatMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ChatMessage)
}

void ChatMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  chattype_ = 0;
  chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ChatMessage::~ChatMessage() {
  // @@protoc_insertion_point(destructor:ChatMessage)
  SharedDtor();
}

void ChatMessage::SharedDtor() {
  if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete chattext_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ChatMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ChatMessage& ChatMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

ChatMessage* ChatMessage::default_instance_ = NULL;

ChatMessage* ChatMessage::New() const {
  return new ChatMessage;
}

void ChatMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ChatMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(gameid_, playerid_);
    chattype_ = 0;
    if (has_chattext()) {
      if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        chattext_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ChatMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ChatMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 gameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_playerId;
        break;
      }

      // optional uint32 playerId = 2;
      case 2: {
        if (tag == 16) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_chatType;
        break;
      }

      // required .ChatMessage.ChatType chatType = 3;
      case 3: {
        if (tag == 24) {
         parse_chatType:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::ChatMessage_ChatType_IsValid(value)) {
            set_chattype(static_cast< ::ChatMessage_ChatType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_chatText;
        break;
      }

      // required string chatText = 4;
      case 4: {
        if (tag == 34) {
         parse_chatText:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_chattext()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ChatMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ChatMessage)
  return false;
#undef DO_
}

void ChatMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ChatMessage)
  // optional uint32 gameId = 1;
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->gameid(), output);
  }

  // optional uint32 playerId = 2;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->playerid(), output);
  }

  // required .ChatMessage.ChatType chatType = 3;
  if (has_chattype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->chattype(), output);
  }

  // required string chatText = 4;
  if (has_chattext()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->chattext(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ChatMessage)
}

int ChatMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional uint32 gameId = 1;
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // optional uint32 playerId = 2;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required .ChatMessage.ChatType chatType = 3;
    if (has_chattype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->chattype());
    }

    // required string chatText = 4;
    if (has_chattext()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->chattext());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ChatMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ChatMessage*>(&from));
}

void ChatMessage::MergeFrom(const ChatMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_chattype()) {
      set_chattype(from.chattype());
    }
    if (from.has_chattext()) {
      set_chattext(from.chattext());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ChatMessage::CopyFrom(const ChatMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ChatMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000c) != 0x0000000c) return false;

  return true;
}

void ChatMessage::Swap(ChatMessage* other) {
  if (other != this) {
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(chattype_, other->chattype_);
    std::swap(chattext_, other->chattext_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ChatMessage::GetTypeName() const {
  return "ChatMessage";
}


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

#ifndef _MSC_VER
const int ChatRejectMessage::kChatTextFieldNumber;
#endif  // !_MSC_VER

ChatRejectMessage::ChatRejectMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ChatRejectMessage)
}

void ChatRejectMessage::InitAsDefaultInstance() {
}

ChatRejectMessage::ChatRejectMessage(const ChatRejectMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ChatRejectMessage)
}

void ChatRejectMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  chattext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ChatRejectMessage::~ChatRejectMessage() {
  // @@protoc_insertion_point(destructor:ChatRejectMessage)
  SharedDtor();
}

void ChatRejectMessage::SharedDtor() {
  if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete chattext_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ChatRejectMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ChatRejectMessage& ChatRejectMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

ChatRejectMessage* ChatRejectMessage::default_instance_ = NULL;

ChatRejectMessage* ChatRejectMessage::New() const {
  return new ChatRejectMessage;
}

void ChatRejectMessage::Clear() {
  if (has_chattext()) {
    if (chattext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      chattext_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ChatRejectMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ChatRejectMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string chatText = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_chattext()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ChatRejectMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ChatRejectMessage)
  return false;
#undef DO_
}

void ChatRejectMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ChatRejectMessage)
  // required string chatText = 1;
  if (has_chattext()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->chattext(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ChatRejectMessage)
}

int ChatRejectMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string chatText = 1;
    if (has_chattext()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->chattext());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ChatRejectMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ChatRejectMessage*>(&from));
}

void ChatRejectMessage::MergeFrom(const ChatRejectMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_chattext()) {
      set_chattext(from.chattext());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ChatRejectMessage::CopyFrom(const ChatRejectMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ChatRejectMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void ChatRejectMessage::Swap(ChatRejectMessage* other) {
  if (other != this) {
    std::swap(chattext_, other->chattext_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ChatRejectMessage::GetTypeName() const {
  return "ChatRejectMessage";
}


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

#ifndef _MSC_VER
const int DialogMessage::kNotificationTextFieldNumber;
#endif  // !_MSC_VER

DialogMessage::DialogMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:DialogMessage)
}

void DialogMessage::InitAsDefaultInstance() {
}

DialogMessage::DialogMessage(const DialogMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:DialogMessage)
}

void DialogMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  notificationtext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DialogMessage::~DialogMessage() {
  // @@protoc_insertion_point(destructor:DialogMessage)
  SharedDtor();
}

void DialogMessage::SharedDtor() {
  if (notificationtext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete notificationtext_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void DialogMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DialogMessage& DialogMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

DialogMessage* DialogMessage::default_instance_ = NULL;

DialogMessage* DialogMessage::New() const {
  return new DialogMessage;
}

void DialogMessage::Clear() {
  if (has_notificationtext()) {
    if (notificationtext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      notificationtext_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool DialogMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:DialogMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string notificationText = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_notificationtext()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:DialogMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:DialogMessage)
  return false;
#undef DO_
}

void DialogMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:DialogMessage)
  // required string notificationText = 1;
  if (has_notificationtext()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->notificationtext(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:DialogMessage)
}

int DialogMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string notificationText = 1;
    if (has_notificationtext()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->notificationtext());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DialogMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DialogMessage*>(&from));
}

void DialogMessage::MergeFrom(const DialogMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_notificationtext()) {
      set_notificationtext(from.notificationtext());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void DialogMessage::CopyFrom(const DialogMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DialogMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void DialogMessage::Swap(DialogMessage* other) {
  if (other != this) {
    std::swap(notificationtext_, other->notificationtext_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string DialogMessage::GetTypeName() const {
  return "DialogMessage";
}


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

bool TimeoutWarningMessage_TimeoutReason_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const TimeoutWarningMessage_TimeoutReason TimeoutWarningMessage::timeoutNoDataReceived;
const TimeoutWarningMessage_TimeoutReason TimeoutWarningMessage::timeoutInactiveGame;
const TimeoutWarningMessage_TimeoutReason TimeoutWarningMessage::timeoutKickAfterAutofold;
const TimeoutWarningMessage_TimeoutReason TimeoutWarningMessage::TimeoutReason_MIN;
const TimeoutWarningMessage_TimeoutReason TimeoutWarningMessage::TimeoutReason_MAX;
const int TimeoutWarningMessage::TimeoutReason_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int TimeoutWarningMessage::kTimeoutReasonFieldNumber;
const int TimeoutWarningMessage::kRemainingSecondsFieldNumber;
#endif  // !_MSC_VER

TimeoutWarningMessage::TimeoutWarningMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:TimeoutWarningMessage)
}

void TimeoutWarningMessage::InitAsDefaultInstance() {
}

TimeoutWarningMessage::TimeoutWarningMessage(const TimeoutWarningMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:TimeoutWarningMessage)
}

void TimeoutWarningMessage::SharedCtor() {
  _cached_size_ = 0;
  timeoutreason_ = 0;
  remainingseconds_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

TimeoutWarningMessage::~TimeoutWarningMessage() {
  // @@protoc_insertion_point(destructor:TimeoutWarningMessage)
  SharedDtor();
}

void TimeoutWarningMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void TimeoutWarningMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const TimeoutWarningMessage& TimeoutWarningMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

TimeoutWarningMessage* TimeoutWarningMessage::default_instance_ = NULL;

TimeoutWarningMessage* TimeoutWarningMessage::New() const {
  return new TimeoutWarningMessage;
}

void TimeoutWarningMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<TimeoutWarningMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(timeoutreason_, remainingseconds_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool TimeoutWarningMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:TimeoutWarningMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .TimeoutWarningMessage.TimeoutReason timeoutReason = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::TimeoutWarningMessage_TimeoutReason_IsValid(value)) {
            set_timeoutreason(static_cast< ::TimeoutWarningMessage_TimeoutReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_remainingSeconds;
        break;
      }

      // required uint32 remainingSeconds = 2;
      case 2: {
        if (tag == 16) {
         parse_remainingSeconds:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &remainingseconds_)));
          set_has_remainingseconds();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:TimeoutWarningMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:TimeoutWarningMessage)
  return false;
#undef DO_
}

void TimeoutWarningMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:TimeoutWarningMessage)
  // required .TimeoutWarningMessage.TimeoutReason timeoutReason = 1;
  if (has_timeoutreason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->timeoutreason(), output);
  }

  // required uint32 remainingSeconds = 2;
  if (has_remainingseconds()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->remainingseconds(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:TimeoutWarningMessage)
}

int TimeoutWarningMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .TimeoutWarningMessage.TimeoutReason timeoutReason = 1;
    if (has_timeoutreason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->timeoutreason());
    }

    // required uint32 remainingSeconds = 2;
    if (has_remainingseconds()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->remainingseconds());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void TimeoutWarningMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const TimeoutWarningMessage*>(&from));
}

void TimeoutWarningMessage::MergeFrom(const TimeoutWarningMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_timeoutreason()) {
      set_timeoutreason(from.timeoutreason());
    }
    if (from.has_remainingseconds()) {
      set_remainingseconds(from.remainingseconds());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void TimeoutWarningMessage::CopyFrom(const TimeoutWarningMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TimeoutWarningMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void TimeoutWarningMessage::Swap(TimeoutWarningMessage* other) {
  if (other != this) {
    std::swap(timeoutreason_, other->timeoutreason_);
    std::swap(remainingseconds_, other->remainingseconds_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string TimeoutWarningMessage::GetTypeName() const {
  return "TimeoutWarningMessage";
}


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

#ifndef _MSC_VER
#endif  // !_MSC_VER

ResetTimeoutMessage::ResetTimeoutMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ResetTimeoutMessage)
}

void ResetTimeoutMessage::InitAsDefaultInstance() {
}

ResetTimeoutMessage::ResetTimeoutMessage(const ResetTimeoutMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ResetTimeoutMessage)
}

void ResetTimeoutMessage::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ResetTimeoutMessage::~ResetTimeoutMessage() {
  // @@protoc_insertion_point(destructor:ResetTimeoutMessage)
  SharedDtor();
}

void ResetTimeoutMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ResetTimeoutMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ResetTimeoutMessage& ResetTimeoutMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

ResetTimeoutMessage* ResetTimeoutMessage::default_instance_ = NULL;

ResetTimeoutMessage* ResetTimeoutMessage::New() const {
  return new ResetTimeoutMessage;
}

void ResetTimeoutMessage::Clear() {
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ResetTimeoutMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ResetTimeoutMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0 ||
        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormatLite::SkipField(
        input, tag, &unknown_fields_stream));
  }
success:
  // @@protoc_insertion_point(parse_success:ResetTimeoutMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ResetTimeoutMessage)
  return false;
#undef DO_
}

void ResetTimeoutMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ResetTimeoutMessage)
  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ResetTimeoutMessage)
}

int ResetTimeoutMessage::ByteSize() const {
  int total_size = 0;

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ResetTimeoutMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ResetTimeoutMessage*>(&from));
}

void ResetTimeoutMessage::MergeFrom(const ResetTimeoutMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ResetTimeoutMessage::CopyFrom(const ResetTimeoutMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ResetTimeoutMessage::IsInitialized() const {

  return true;
}

void ResetTimeoutMessage::Swap(ResetTimeoutMessage* other) {
  if (other != this) {
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ResetTimeoutMessage::GetTypeName() const {
  return "ResetTimeoutMessage";
}


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

#ifndef _MSC_VER
const int ReportAvatarMessage::kReportedPlayerIdFieldNumber;
const int ReportAvatarMessage::kReportedAvatarHashFieldNumber;
#endif  // !_MSC_VER

ReportAvatarMessage::ReportAvatarMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ReportAvatarMessage)
}

void ReportAvatarMessage::InitAsDefaultInstance() {
}

ReportAvatarMessage::ReportAvatarMessage(const ReportAvatarMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ReportAvatarMessage)
}

void ReportAvatarMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  reportedplayerid_ = 0u;
  reportedavatarhash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ReportAvatarMessage::~ReportAvatarMessage() {
  // @@protoc_insertion_point(destructor:ReportAvatarMessage)
  SharedDtor();
}

void ReportAvatarMessage::SharedDtor() {
  if (reportedavatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete reportedavatarhash_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ReportAvatarMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ReportAvatarMessage& ReportAvatarMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

ReportAvatarMessage* ReportAvatarMessage::default_instance_ = NULL;

ReportAvatarMessage* ReportAvatarMessage::New() const {
  return new ReportAvatarMessage;
}

void ReportAvatarMessage::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    reportedplayerid_ = 0u;
    if (has_reportedavatarhash()) {
      if (reportedavatarhash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        reportedavatarhash_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ReportAvatarMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ReportAvatarMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 reportedPlayerId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &reportedplayerid_)));
          set_has_reportedplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_reportedAvatarHash;
        break;
      }

      // required bytes reportedAvatarHash = 2;
      case 2: {
        if (tag == 18) {
         parse_reportedAvatarHash:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_reportedavatarhash()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ReportAvatarMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ReportAvatarMessage)
  return false;
#undef DO_
}

void ReportAvatarMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ReportAvatarMessage)
  // required uint32 reportedPlayerId = 1;
  if (has_reportedplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->reportedplayerid(), output);
  }

  // required bytes reportedAvatarHash = 2;
  if (has_reportedavatarhash()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->reportedavatarhash(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ReportAvatarMessage)
}

int ReportAvatarMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 reportedPlayerId = 1;
    if (has_reportedplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->reportedplayerid());
    }

    // required bytes reportedAvatarHash = 2;
    if (has_reportedavatarhash()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->reportedavatarhash());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ReportAvatarMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ReportAvatarMessage*>(&from));
}

void ReportAvatarMessage::MergeFrom(const ReportAvatarMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_reportedplayerid()) {
      set_reportedplayerid(from.reportedplayerid());
    }
    if (from.has_reportedavatarhash()) {
      set_reportedavatarhash(from.reportedavatarhash());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ReportAvatarMessage::CopyFrom(const ReportAvatarMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ReportAvatarMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void ReportAvatarMessage::Swap(ReportAvatarMessage* other) {
  if (other != this) {
    std::swap(reportedplayerid_, other->reportedplayerid_);
    std::swap(reportedavatarhash_, other->reportedavatarhash_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ReportAvatarMessage::GetTypeName() const {
  return "ReportAvatarMessage";
}


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

bool ReportAvatarAckMessage_ReportAvatarResult_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const ReportAvatarAckMessage_ReportAvatarResult ReportAvatarAckMessage::avatarReportAccepted;
const ReportAvatarAckMessage_ReportAvatarResult ReportAvatarAckMessage::avatarReportDuplicate;
const ReportAvatarAckMessage_ReportAvatarResult ReportAvatarAckMessage::avatarReportInvalid;
const ReportAvatarAckMessage_ReportAvatarResult ReportAvatarAckMessage::ReportAvatarResult_MIN;
const ReportAvatarAckMessage_ReportAvatarResult ReportAvatarAckMessage::ReportAvatarResult_MAX;
const int ReportAvatarAckMessage::ReportAvatarResult_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int ReportAvatarAckMessage::kReportedPlayerIdFieldNumber;
const int ReportAvatarAckMessage::kReportAvatarResultFieldNumber;
#endif  // !_MSC_VER

ReportAvatarAckMessage::ReportAvatarAckMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ReportAvatarAckMessage)
}

void ReportAvatarAckMessage::InitAsDefaultInstance() {
}

ReportAvatarAckMessage::ReportAvatarAckMessage(const ReportAvatarAckMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ReportAvatarAckMessage)
}

void ReportAvatarAckMessage::SharedCtor() {
  _cached_size_ = 0;
  reportedplayerid_ = 0u;
  reportavatarresult_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ReportAvatarAckMessage::~ReportAvatarAckMessage() {
  // @@protoc_insertion_point(destructor:ReportAvatarAckMessage)
  SharedDtor();
}

void ReportAvatarAckMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ReportAvatarAckMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ReportAvatarAckMessage& ReportAvatarAckMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

ReportAvatarAckMessage* ReportAvatarAckMessage::default_instance_ = NULL;

ReportAvatarAckMessage* ReportAvatarAckMessage::New() const {
  return new ReportAvatarAckMessage;
}

void ReportAvatarAckMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ReportAvatarAckMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(reportedplayerid_, reportavatarresult_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ReportAvatarAckMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ReportAvatarAckMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 reportedPlayerId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &reportedplayerid_)));
          set_has_reportedplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_reportAvatarResult;
        break;
      }

      // required .ReportAvatarAckMessage.ReportAvatarResult reportAvatarResult = 2;
      case 2: {
        if (tag == 16) {
         parse_reportAvatarResult:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::ReportAvatarAckMessage_ReportAvatarResult_IsValid(value)) {
            set_reportavatarresult(static_cast< ::ReportAvatarAckMessage_ReportAvatarResult >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ReportAvatarAckMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ReportAvatarAckMessage)
  return false;
#undef DO_
}

void ReportAvatarAckMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ReportAvatarAckMessage)
  // required uint32 reportedPlayerId = 1;
  if (has_reportedplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->reportedplayerid(), output);
  }

  // required .ReportAvatarAckMessage.ReportAvatarResult reportAvatarResult = 2;
  if (has_reportavatarresult()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->reportavatarresult(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ReportAvatarAckMessage)
}

int ReportAvatarAckMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 reportedPlayerId = 1;
    if (has_reportedplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->reportedplayerid());
    }

    // required .ReportAvatarAckMessage.ReportAvatarResult reportAvatarResult = 2;
    if (has_reportavatarresult()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->reportavatarresult());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ReportAvatarAckMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ReportAvatarAckMessage*>(&from));
}

void ReportAvatarAckMessage::MergeFrom(const ReportAvatarAckMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_reportedplayerid()) {
      set_reportedplayerid(from.reportedplayerid());
    }
    if (from.has_reportavatarresult()) {
      set_reportavatarresult(from.reportavatarresult());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ReportAvatarAckMessage::CopyFrom(const ReportAvatarAckMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ReportAvatarAckMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void ReportAvatarAckMessage::Swap(ReportAvatarAckMessage* other) {
  if (other != this) {
    std::swap(reportedplayerid_, other->reportedplayerid_);
    std::swap(reportavatarresult_, other->reportavatarresult_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ReportAvatarAckMessage::GetTypeName() const {
  return "ReportAvatarAckMessage";
}


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

#ifndef _MSC_VER
const int ReportGameMessage::kReportedGameIdFieldNumber;
#endif  // !_MSC_VER

ReportGameMessage::ReportGameMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ReportGameMessage)
}

void ReportGameMessage::InitAsDefaultInstance() {
}

ReportGameMessage::ReportGameMessage(const ReportGameMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ReportGameMessage)
}

void ReportGameMessage::SharedCtor() {
  _cached_size_ = 0;
  reportedgameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ReportGameMessage::~ReportGameMessage() {
  // @@protoc_insertion_point(destructor:ReportGameMessage)
  SharedDtor();
}

void ReportGameMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ReportGameMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ReportGameMessage& ReportGameMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

ReportGameMessage* ReportGameMessage::default_instance_ = NULL;

ReportGameMessage* ReportGameMessage::New() const {
  return new ReportGameMessage;
}

void ReportGameMessage::Clear() {
  reportedgameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ReportGameMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ReportGameMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 reportedGameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &reportedgameid_)));
          set_has_reportedgameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ReportGameMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ReportGameMessage)
  return false;
#undef DO_
}

void ReportGameMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ReportGameMessage)
  // required uint32 reportedGameId = 1;
  if (has_reportedgameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->reportedgameid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ReportGameMessage)
}

int ReportGameMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 reportedGameId = 1;
    if (has_reportedgameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->reportedgameid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ReportGameMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ReportGameMessage*>(&from));
}

void ReportGameMessage::MergeFrom(const ReportGameMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_reportedgameid()) {
      set_reportedgameid(from.reportedgameid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ReportGameMessage::CopyFrom(const ReportGameMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ReportGameMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void ReportGameMessage::Swap(ReportGameMessage* other) {
  if (other != this) {
    std::swap(reportedgameid_, other->reportedgameid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ReportGameMessage::GetTypeName() const {
  return "ReportGameMessage";
}


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

bool ReportGameAckMessage_ReportGameResult_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const ReportGameAckMessage_ReportGameResult ReportGameAckMessage::gameReportAccepted;
const ReportGameAckMessage_ReportGameResult ReportGameAckMessage::gameReportDuplicate;
const ReportGameAckMessage_ReportGameResult ReportGameAckMessage::gameReportInvalid;
const ReportGameAckMessage_ReportGameResult ReportGameAckMessage::ReportGameResult_MIN;
const ReportGameAckMessage_ReportGameResult ReportGameAckMessage::ReportGameResult_MAX;
const int ReportGameAckMessage::ReportGameResult_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int ReportGameAckMessage::kReportedGameIdFieldNumber;
const int ReportGameAckMessage::kReportGameResultFieldNumber;
#endif  // !_MSC_VER

ReportGameAckMessage::ReportGameAckMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ReportGameAckMessage)
}

void ReportGameAckMessage::InitAsDefaultInstance() {
}

ReportGameAckMessage::ReportGameAckMessage(const ReportGameAckMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ReportGameAckMessage)
}

void ReportGameAckMessage::SharedCtor() {
  _cached_size_ = 0;
  reportedgameid_ = 0u;
  reportgameresult_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ReportGameAckMessage::~ReportGameAckMessage() {
  // @@protoc_insertion_point(destructor:ReportGameAckMessage)
  SharedDtor();
}

void ReportGameAckMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ReportGameAckMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ReportGameAckMessage& ReportGameAckMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

ReportGameAckMessage* ReportGameAckMessage::default_instance_ = NULL;

ReportGameAckMessage* ReportGameAckMessage::New() const {
  return new ReportGameAckMessage;
}

void ReportGameAckMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ReportGameAckMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(reportedgameid_, reportgameresult_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ReportGameAckMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ReportGameAckMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 reportedGameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &reportedgameid_)));
          set_has_reportedgameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_reportGameResult;
        break;
      }

      // required .ReportGameAckMessage.ReportGameResult reportGameResult = 2;
      case 2: {
        if (tag == 16) {
         parse_reportGameResult:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::ReportGameAckMessage_ReportGameResult_IsValid(value)) {
            set_reportgameresult(static_cast< ::ReportGameAckMessage_ReportGameResult >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ReportGameAckMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ReportGameAckMessage)
  return false;
#undef DO_
}

void ReportGameAckMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ReportGameAckMessage)
  // required uint32 reportedGameId = 1;
  if (has_reportedgameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->reportedgameid(), output);
  }

  // required .ReportGameAckMessage.ReportGameResult reportGameResult = 2;
  if (has_reportgameresult()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->reportgameresult(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ReportGameAckMessage)
}

int ReportGameAckMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 reportedGameId = 1;
    if (has_reportedgameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->reportedgameid());
    }

    // required .ReportGameAckMessage.ReportGameResult reportGameResult = 2;
    if (has_reportgameresult()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->reportgameresult());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ReportGameAckMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ReportGameAckMessage*>(&from));
}

void ReportGameAckMessage::MergeFrom(const ReportGameAckMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_reportedgameid()) {
      set_reportedgameid(from.reportedgameid());
    }
    if (from.has_reportgameresult()) {
      set_reportgameresult(from.reportgameresult());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ReportGameAckMessage::CopyFrom(const ReportGameAckMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ReportGameAckMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void ReportGameAckMessage::Swap(ReportGameAckMessage* other) {
  if (other != this) {
    std::swap(reportedgameid_, other->reportedgameid_);
    std::swap(reportgameresult_, other->reportgameresult_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ReportGameAckMessage::GetTypeName() const {
  return "ReportGameAckMessage";
}


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

bool ErrorMessage_ErrorReason_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:
    case 12:
    case 13:
    case 14:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const ErrorMessage_ErrorReason ErrorMessage::reserved;
const ErrorMessage_ErrorReason ErrorMessage::initVersionNotSupported;
const ErrorMessage_ErrorReason ErrorMessage::initServerFull;
const ErrorMessage_ErrorReason ErrorMessage::initAuthFailure;
const ErrorMessage_ErrorReason ErrorMessage::initPlayerNameInUse;
const ErrorMessage_ErrorReason ErrorMessage::initInvalidPlayerName;
const ErrorMessage_ErrorReason ErrorMessage::initServerMaintenance;
const ErrorMessage_ErrorReason ErrorMessage::initBlocked;
const ErrorMessage_ErrorReason ErrorMessage::avatarTooLarge;
const ErrorMessage_ErrorReason ErrorMessage::invalidPacket;
const ErrorMessage_ErrorReason ErrorMessage::invalidState;
const ErrorMessage_ErrorReason ErrorMessage::kickedFromServer;
const ErrorMessage_ErrorReason ErrorMessage::bannedFromServer;
const ErrorMessage_ErrorReason ErrorMessage::blockedByServer;
const ErrorMessage_ErrorReason ErrorMessage::sessionTimeout;
const ErrorMessage_ErrorReason ErrorMessage::ErrorReason_MIN;
const ErrorMessage_ErrorReason ErrorMessage::ErrorReason_MAX;
const int ErrorMessage::ErrorReason_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int ErrorMessage::kErrorReasonFieldNumber;
#endif  // !_MSC_VER

ErrorMessage::ErrorMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ErrorMessage)
}

void ErrorMessage::InitAsDefaultInstance() {
}

ErrorMessage::ErrorMessage(const ErrorMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ErrorMessage)
}

void ErrorMessage::SharedCtor() {
  _cached_size_ = 0;
  errorreason_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ErrorMessage::~ErrorMessage() {
  // @@protoc_insertion_point(destructor:ErrorMessage)
  SharedDtor();
}

void ErrorMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ErrorMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ErrorMessage& ErrorMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

ErrorMessage* ErrorMessage::default_instance_ = NULL;

ErrorMessage* ErrorMessage::New() const {
  return new ErrorMessage;
}

void ErrorMessage::Clear() {
  errorreason_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ErrorMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ErrorMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .ErrorMessage.ErrorReason errorReason = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::ErrorMessage_ErrorReason_IsValid(value)) {
            set_errorreason(static_cast< ::ErrorMessage_ErrorReason >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ErrorMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ErrorMessage)
  return false;
#undef DO_
}

void ErrorMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ErrorMessage)
  // required .ErrorMessage.ErrorReason errorReason = 1;
  if (has_errorreason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->errorreason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ErrorMessage)
}

int ErrorMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .ErrorMessage.ErrorReason errorReason = 1;
    if (has_errorreason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->errorreason());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ErrorMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ErrorMessage*>(&from));
}

void ErrorMessage::MergeFrom(const ErrorMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_errorreason()) {
      set_errorreason(from.errorreason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ErrorMessage::CopyFrom(const ErrorMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ErrorMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void ErrorMessage::Swap(ErrorMessage* other) {
  if (other != this) {
    std::swap(errorreason_, other->errorreason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ErrorMessage::GetTypeName() const {
  return "ErrorMessage";
}


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

#ifndef _MSC_VER
const int AdminRemoveGameMessage::kRemoveGameIdFieldNumber;
#endif  // !_MSC_VER

AdminRemoveGameMessage::AdminRemoveGameMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AdminRemoveGameMessage)
}

void AdminRemoveGameMessage::InitAsDefaultInstance() {
}

AdminRemoveGameMessage::AdminRemoveGameMessage(const AdminRemoveGameMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AdminRemoveGameMessage)
}

void AdminRemoveGameMessage::SharedCtor() {
  _cached_size_ = 0;
  removegameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AdminRemoveGameMessage::~AdminRemoveGameMessage() {
  // @@protoc_insertion_point(destructor:AdminRemoveGameMessage)
  SharedDtor();
}

void AdminRemoveGameMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AdminRemoveGameMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AdminRemoveGameMessage& AdminRemoveGameMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AdminRemoveGameMessage* AdminRemoveGameMessage::default_instance_ = NULL;

AdminRemoveGameMessage* AdminRemoveGameMessage::New() const {
  return new AdminRemoveGameMessage;
}

void AdminRemoveGameMessage::Clear() {
  removegameid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AdminRemoveGameMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AdminRemoveGameMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 removeGameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &removegameid_)));
          set_has_removegameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AdminRemoveGameMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AdminRemoveGameMessage)
  return false;
#undef DO_
}

void AdminRemoveGameMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AdminRemoveGameMessage)
  // required uint32 removeGameId = 1;
  if (has_removegameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->removegameid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AdminRemoveGameMessage)
}

int AdminRemoveGameMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 removeGameId = 1;
    if (has_removegameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->removegameid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AdminRemoveGameMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AdminRemoveGameMessage*>(&from));
}

void AdminRemoveGameMessage::MergeFrom(const AdminRemoveGameMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_removegameid()) {
      set_removegameid(from.removegameid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AdminRemoveGameMessage::CopyFrom(const AdminRemoveGameMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AdminRemoveGameMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void AdminRemoveGameMessage::Swap(AdminRemoveGameMessage* other) {
  if (other != this) {
    std::swap(removegameid_, other->removegameid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AdminRemoveGameMessage::GetTypeName() const {
  return "AdminRemoveGameMessage";
}


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

bool AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::gameRemoveAccepted;
const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::gameRemoveInvalid;
const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::AdminRemoveGameResult_MIN;
const AdminRemoveGameAckMessage_AdminRemoveGameResult AdminRemoveGameAckMessage::AdminRemoveGameResult_MAX;
const int AdminRemoveGameAckMessage::AdminRemoveGameResult_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int AdminRemoveGameAckMessage::kRemoveGameIdFieldNumber;
const int AdminRemoveGameAckMessage::kRemoveGameResultFieldNumber;
#endif  // !_MSC_VER

AdminRemoveGameAckMessage::AdminRemoveGameAckMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AdminRemoveGameAckMessage)
}

void AdminRemoveGameAckMessage::InitAsDefaultInstance() {
}

AdminRemoveGameAckMessage::AdminRemoveGameAckMessage(const AdminRemoveGameAckMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AdminRemoveGameAckMessage)
}

void AdminRemoveGameAckMessage::SharedCtor() {
  _cached_size_ = 0;
  removegameid_ = 0u;
  removegameresult_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AdminRemoveGameAckMessage::~AdminRemoveGameAckMessage() {
  // @@protoc_insertion_point(destructor:AdminRemoveGameAckMessage)
  SharedDtor();
}

void AdminRemoveGameAckMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AdminRemoveGameAckMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AdminRemoveGameAckMessage& AdminRemoveGameAckMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AdminRemoveGameAckMessage* AdminRemoveGameAckMessage::default_instance_ = NULL;

AdminRemoveGameAckMessage* AdminRemoveGameAckMessage::New() const {
  return new AdminRemoveGameAckMessage;
}

void AdminRemoveGameAckMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<AdminRemoveGameAckMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(removegameid_, removegameresult_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AdminRemoveGameAckMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AdminRemoveGameAckMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 removeGameId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &removegameid_)));
          set_has_removegameid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_removeGameResult;
        break;
      }

      // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2;
      case 2: {
        if (tag == 16) {
         parse_removeGameResult:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::AdminRemoveGameAckMessage_AdminRemoveGameResult_IsValid(value)) {
            set_removegameresult(static_cast< ::AdminRemoveGameAckMessage_AdminRemoveGameResult >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AdminRemoveGameAckMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AdminRemoveGameAckMessage)
  return false;
#undef DO_
}

void AdminRemoveGameAckMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AdminRemoveGameAckMessage)
  // required uint32 removeGameId = 1;
  if (has_removegameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->removegameid(), output);
  }

  // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2;
  if (has_removegameresult()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->removegameresult(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AdminRemoveGameAckMessage)
}

int AdminRemoveGameAckMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 removeGameId = 1;
    if (has_removegameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->removegameid());
    }

    // required .AdminRemoveGameAckMessage.AdminRemoveGameResult removeGameResult = 2;
    if (has_removegameresult()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->removegameresult());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AdminRemoveGameAckMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AdminRemoveGameAckMessage*>(&from));
}

void AdminRemoveGameAckMessage::MergeFrom(const AdminRemoveGameAckMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_removegameid()) {
      set_removegameid(from.removegameid());
    }
    if (from.has_removegameresult()) {
      set_removegameresult(from.removegameresult());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AdminRemoveGameAckMessage::CopyFrom(const AdminRemoveGameAckMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AdminRemoveGameAckMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void AdminRemoveGameAckMessage::Swap(AdminRemoveGameAckMessage* other) {
  if (other != this) {
    std::swap(removegameid_, other->removegameid_);
    std::swap(removegameresult_, other->removegameresult_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AdminRemoveGameAckMessage::GetTypeName() const {
  return "AdminRemoveGameAckMessage";
}


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

#ifndef _MSC_VER
const int AdminBanPlayerMessage::kBanPlayerIdFieldNumber;
#endif  // !_MSC_VER

AdminBanPlayerMessage::AdminBanPlayerMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AdminBanPlayerMessage)
}

void AdminBanPlayerMessage::InitAsDefaultInstance() {
}

AdminBanPlayerMessage::AdminBanPlayerMessage(const AdminBanPlayerMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AdminBanPlayerMessage)
}

void AdminBanPlayerMessage::SharedCtor() {
  _cached_size_ = 0;
  banplayerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AdminBanPlayerMessage::~AdminBanPlayerMessage() {
  // @@protoc_insertion_point(destructor:AdminBanPlayerMessage)
  SharedDtor();
}

void AdminBanPlayerMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AdminBanPlayerMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AdminBanPlayerMessage& AdminBanPlayerMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AdminBanPlayerMessage* AdminBanPlayerMessage::default_instance_ = NULL;

AdminBanPlayerMessage* AdminBanPlayerMessage::New() const {
  return new AdminBanPlayerMessage;
}

void AdminBanPlayerMessage::Clear() {
  banplayerid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AdminBanPlayerMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AdminBanPlayerMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 banPlayerId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &banplayerid_)));
          set_has_banplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AdminBanPlayerMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AdminBanPlayerMessage)
  return false;
#undef DO_
}

void AdminBanPlayerMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AdminBanPlayerMessage)
  // required uint32 banPlayerId = 1;
  if (has_banplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->banplayerid(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AdminBanPlayerMessage)
}

int AdminBanPlayerMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 banPlayerId = 1;
    if (has_banplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->banplayerid());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AdminBanPlayerMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AdminBanPlayerMessage*>(&from));
}

void AdminBanPlayerMessage::MergeFrom(const AdminBanPlayerMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_banplayerid()) {
      set_banplayerid(from.banplayerid());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AdminBanPlayerMessage::CopyFrom(const AdminBanPlayerMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AdminBanPlayerMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void AdminBanPlayerMessage::Swap(AdminBanPlayerMessage* other) {
  if (other != this) {
    std::swap(banplayerid_, other->banplayerid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AdminBanPlayerMessage::GetTypeName() const {
  return "AdminBanPlayerMessage";
}


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

bool AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerAccepted;
const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerPending;
const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerNoDB;
const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerDBError;
const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::banPlayerInvalid;
const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::AdminBanPlayerResult_MIN;
const AdminBanPlayerAckMessage_AdminBanPlayerResult AdminBanPlayerAckMessage::AdminBanPlayerResult_MAX;
const int AdminBanPlayerAckMessage::AdminBanPlayerResult_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int AdminBanPlayerAckMessage::kBanPlayerIdFieldNumber;
const int AdminBanPlayerAckMessage::kBanPlayerResultFieldNumber;
#endif  // !_MSC_VER

AdminBanPlayerAckMessage::AdminBanPlayerAckMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AdminBanPlayerAckMessage)
}

void AdminBanPlayerAckMessage::InitAsDefaultInstance() {
}

AdminBanPlayerAckMessage::AdminBanPlayerAckMessage(const AdminBanPlayerAckMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AdminBanPlayerAckMessage)
}

void AdminBanPlayerAckMessage::SharedCtor() {
  _cached_size_ = 0;
  banplayerid_ = 0u;
  banplayerresult_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AdminBanPlayerAckMessage::~AdminBanPlayerAckMessage() {
  // @@protoc_insertion_point(destructor:AdminBanPlayerAckMessage)
  SharedDtor();
}

void AdminBanPlayerAckMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void AdminBanPlayerAckMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AdminBanPlayerAckMessage& AdminBanPlayerAckMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

AdminBanPlayerAckMessage* AdminBanPlayerAckMessage::default_instance_ = NULL;

AdminBanPlayerAckMessage* AdminBanPlayerAckMessage::New() const {
  return new AdminBanPlayerAckMessage;
}

void AdminBanPlayerAckMessage::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<AdminBanPlayerAckMessage*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(banplayerid_, banplayerresult_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AdminBanPlayerAckMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AdminBanPlayerAckMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 banPlayerId = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &banplayerid_)));
          set_has_banplayerid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_banPlayerResult;
        break;
      }

      // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2;
      case 2: {
        if (tag == 16) {
         parse_banPlayerResult:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::AdminBanPlayerAckMessage_AdminBanPlayerResult_IsValid(value)) {
            set_banplayerresult(static_cast< ::AdminBanPlayerAckMessage_AdminBanPlayerResult >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AdminBanPlayerAckMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AdminBanPlayerAckMessage)
  return false;
#undef DO_
}

void AdminBanPlayerAckMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AdminBanPlayerAckMessage)
  // required uint32 banPlayerId = 1;
  if (has_banplayerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->banplayerid(), output);
  }

  // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2;
  if (has_banplayerresult()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->banplayerresult(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AdminBanPlayerAckMessage)
}

int AdminBanPlayerAckMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 banPlayerId = 1;
    if (has_banplayerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->banplayerid());
    }

    // required .AdminBanPlayerAckMessage.AdminBanPlayerResult banPlayerResult = 2;
    if (has_banplayerresult()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->banplayerresult());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AdminBanPlayerAckMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AdminBanPlayerAckMessage*>(&from));
}

void AdminBanPlayerAckMessage::MergeFrom(const AdminBanPlayerAckMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_banplayerid()) {
      set_banplayerid(from.banplayerid());
    }
    if (from.has_banplayerresult()) {
      set_banplayerresult(from.banplayerresult());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AdminBanPlayerAckMessage::CopyFrom(const AdminBanPlayerAckMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AdminBanPlayerAckMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void AdminBanPlayerAckMessage::Swap(AdminBanPlayerAckMessage* other) {
  if (other != this) {
    std::swap(banplayerid_, other->banplayerid_);
    std::swap(banplayerresult_, other->banplayerresult_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AdminBanPlayerAckMessage::GetTypeName() const {
  return "AdminBanPlayerAckMessage";
}


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

bool PokerTHMessage_PokerTHMessageType_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
    case 47:
    case 48:
    case 49:
    case 50:
    case 51:
    case 52:
    case 53:
    case 54:
    case 55:
    case 56:
    case 57:
    case 58:
    case 59:
    case 60:
    case 61:
    case 62:
    case 63:
    case 64:
    case 65:
    case 66:
    case 67:
    case 68:
    case 69:
    case 70:
    case 71:
    case 72:
    case 73:
    case 74:
    case 75:
    case 76:
    case 77:
    case 78:
    case 79:
    case 80:
    case 81:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AnnounceMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_InitMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AuthServerChallengeMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AuthClientResponseMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AuthServerVerificationMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_InitAckMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AvatarRequestMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AvatarHeaderMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AvatarDataMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AvatarEndMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_UnknownAvatarMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_PlayerListMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameListNewMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameListUpdateMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameListPlayerJoinedMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameListPlayerLeftMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameListAdminChangedMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_PlayerInfoRequestMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_PlayerInfoReplyMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_SubscriptionRequestMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_JoinExistingGameMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_JoinNewGameMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_RejoinExistingGameMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_JoinGameAckMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_JoinGameFailedMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GamePlayerJoinedMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GamePlayerLeftMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameAdminChangedMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_RemovedFromGameMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_KickPlayerRequestMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_LeaveGameRequestMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_InvitePlayerToGameMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_InviteNotifyMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_RejectGameInvitationMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_RejectInvNotifyMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_StartEventMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_StartEventAckMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameStartInitialMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameStartRejoinMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_HandStartMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_PlayersTurnMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_MyActionRequestMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_YourActionRejectedMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_PlayersActionDoneMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_DealFlopCardsMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_DealTurnCardMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_DealRiverCardMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AllInShowCardsMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_EndOfHandShowCardsMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_EndOfHandHideCardsMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ShowMyCardsRequestMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AfterHandShowCardsMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_EndOfGameMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_PlayerIdChangedMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AskKickPlayerMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AskKickDeniedMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_StartKickPetitionMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_VoteKickRequestMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_VoteKickReplyMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_KickPetitionUpdateMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_EndKickPetitionMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_StatisticsMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ChatRequestMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ChatMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ChatRejectMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_DialogMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_TimeoutWarningMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ResetTimeoutMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ReportAvatarMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ReportAvatarAckMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ReportGameMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ReportGameAckMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_ErrorMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminRemoveGameMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminRemoveGameAckMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminBanPlayerMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_AdminBanPlayerAckMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameListSpectatorJoinedMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameListSpectatorLeftMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameSpectatorJoinedMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::Type_GameSpectatorLeftMessage;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::PokerTHMessageType_MIN;
const PokerTHMessage_PokerTHMessageType PokerTHMessage::PokerTHMessageType_MAX;
const int PokerTHMessage::PokerTHMessageType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int PokerTHMessage::kMessageTypeFieldNumber;
const int PokerTHMessage::kAnnounceMessageFieldNumber;
const int PokerTHMessage::kInitMessageFieldNumber;
const int PokerTHMessage::kAuthServerChallengeMessageFieldNumber;
const int PokerTHMessage::kAuthClientResponseMessageFieldNumber;
const int PokerTHMessage::kAuthServerVerificationMessageFieldNumber;
const int PokerTHMessage::kInitAckMessageFieldNumber;
const int PokerTHMessage::kAvatarRequestMessageFieldNumber;
const int PokerTHMessage::kAvatarHeaderMessageFieldNumber;
const int PokerTHMessage::kAvatarDataMessageFieldNumber;
const int PokerTHMessage::kAvatarEndMessageFieldNumber;
const int PokerTHMessage::kUnknownAvatarMessageFieldNumber;
const int PokerTHMessage::kPlayerListMessageFieldNumber;
const int PokerTHMessage::kGameListNewMessageFieldNumber;
const int PokerTHMessage::kGameListUpdateMessageFieldNumber;
const int PokerTHMessage::kGameListPlayerJoinedMessageFieldNumber;
const int PokerTHMessage::kGameListPlayerLeftMessageFieldNumber;
const int PokerTHMessage::kGameListAdminChangedMessageFieldNumber;
const int PokerTHMessage::kPlayerInfoRequestMessageFieldNumber;
const int PokerTHMessage::kPlayerInfoReplyMessageFieldNumber;
const int PokerTHMessage::kSubscriptionRequestMessageFieldNumber;
const int PokerTHMessage::kJoinExistingGameMessageFieldNumber;
const int PokerTHMessage::kJoinNewGameMessageFieldNumber;
const int PokerTHMessage::kRejoinExistingGameMessageFieldNumber;
const int PokerTHMessage::kJoinGameAckMessageFieldNumber;
const int PokerTHMessage::kJoinGameFailedMessageFieldNumber;
const int PokerTHMessage::kGamePlayerJoinedMessageFieldNumber;
const int PokerTHMessage::kGamePlayerLeftMessageFieldNumber;
const int PokerTHMessage::kGameAdminChangedMessageFieldNumber;
const int PokerTHMessage::kRemovedFromGameMessageFieldNumber;
const int PokerTHMessage::kKickPlayerRequestMessageFieldNumber;
const int PokerTHMessage::kLeaveGameRequestMessageFieldNumber;
const int PokerTHMessage::kInvitePlayerToGameMessageFieldNumber;
const int PokerTHMessage::kInviteNotifyMessageFieldNumber;
const int PokerTHMessage::kRejectGameInvitationMessageFieldNumber;
const int PokerTHMessage::kRejectInvNotifyMessageFieldNumber;
const int PokerTHMessage::kStartEventMessageFieldNumber;
const int PokerTHMessage::kStartEventAckMessageFieldNumber;
const int PokerTHMessage::kGameStartInitialMessageFieldNumber;
const int PokerTHMessage::kGameStartRejoinMessageFieldNumber;
const int PokerTHMessage::kHandStartMessageFieldNumber;
const int PokerTHMessage::kPlayersTurnMessageFieldNumber;
const int PokerTHMessage::kMyActionRequestMessageFieldNumber;
const int PokerTHMessage::kYourActionRejectedMessageFieldNumber;
const int PokerTHMessage::kPlayersActionDoneMessageFieldNumber;
const int PokerTHMessage::kDealFlopCardsMessageFieldNumber;
const int PokerTHMessage::kDealTurnCardMessageFieldNumber;
const int PokerTHMessage::kDealRiverCardMessageFieldNumber;
const int PokerTHMessage::kAllInShowCardsMessageFieldNumber;
const int PokerTHMessage::kEndOfHandShowCardsMessageFieldNumber;
const int PokerTHMessage::kEndOfHandHideCardsMessageFieldNumber;
const int PokerTHMessage::kShowMyCardsRequestMessageFieldNumber;
const int PokerTHMessage::kAfterHandShowCardsMessageFieldNumber;
const int PokerTHMessage::kEndOfGameMessageFieldNumber;
const int PokerTHMessage::kPlayerIdChangedMessageFieldNumber;
const int PokerTHMessage::kAskKickPlayerMessageFieldNumber;
const int PokerTHMessage::kAskKickDeniedMessageFieldNumber;
const int PokerTHMessage::kStartKickPetitionMessageFieldNumber;
const int PokerTHMessage::kVoteKickRequestMessageFieldNumber;
const int PokerTHMessage::kVoteKickReplyMessageFieldNumber;
const int PokerTHMessage::kKickPetitionUpdateMessageFieldNumber;
const int PokerTHMessage::kEndKickPetitionMessageFieldNumber;
const int PokerTHMessage::kStatisticsMessageFieldNumber;
const int PokerTHMessage::kChatRequestMessageFieldNumber;
const int PokerTHMessage::kChatMessageFieldNumber;
const int PokerTHMessage::kChatRejectMessageFieldNumber;
const int PokerTHMessage::kDialogMessageFieldNumber;
const int PokerTHMessage::kTimeoutWarningMessageFieldNumber;
const int PokerTHMessage::kResetTimeoutMessageFieldNumber;
const int PokerTHMessage::kReportAvatarMessageFieldNumber;
const int PokerTHMessage::kReportAvatarAckMessageFieldNumber;
const int PokerTHMessage::kReportGameMessageFieldNumber;
const int PokerTHMessage::kReportGameAckMessageFieldNumber;
const int PokerTHMessage::kErrorMessageFieldNumber;
const int PokerTHMessage::kAdminRemoveGameMessageFieldNumber;
const int PokerTHMessage::kAdminRemoveGameAckMessageFieldNumber;
const int PokerTHMessage::kAdminBanPlayerMessageFieldNumber;
const int PokerTHMessage::kAdminBanPlayerAckMessageFieldNumber;
const int PokerTHMessage::kGameListSpectatorJoinedMessageFieldNumber;
const int PokerTHMessage::kGameListSpectatorLeftMessageFieldNumber;
const int PokerTHMessage::kGameSpectatorJoinedMessageFieldNumber;
const int PokerTHMessage::kGameSpectatorLeftMessageFieldNumber;
#endif  // !_MSC_VER

PokerTHMessage::PokerTHMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PokerTHMessage)
}

void PokerTHMessage::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  announcemessage_ = const_cast< ::AnnounceMessage*>(
      ::AnnounceMessage::internal_default_instance());
#else
  announcemessage_ = const_cast< ::AnnounceMessage*>(&::AnnounceMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  initmessage_ = const_cast< ::InitMessage*>(
      ::InitMessage::internal_default_instance());
#else
  initmessage_ = const_cast< ::InitMessage*>(&::InitMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  authserverchallengemessage_ = const_cast< ::AuthServerChallengeMessage*>(
      ::AuthServerChallengeMessage::internal_default_instance());
#else
  authserverchallengemessage_ = const_cast< ::AuthServerChallengeMessage*>(&::AuthServerChallengeMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  authclientresponsemessage_ = const_cast< ::AuthClientResponseMessage*>(
      ::AuthClientResponseMessage::internal_default_instance());
#else
  authclientresponsemessage_ = const_cast< ::AuthClientResponseMessage*>(&::AuthClientResponseMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  authserververificationmessage_ = const_cast< ::AuthServerVerificationMessage*>(
      ::AuthServerVerificationMessage::internal_default_instance());
#else
  authserververificationmessage_ = const_cast< ::AuthServerVerificationMessage*>(&::AuthServerVerificationMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  initackmessage_ = const_cast< ::InitAckMessage*>(
      ::InitAckMessage::internal_default_instance());
#else
  initackmessage_ = const_cast< ::InitAckMessage*>(&::InitAckMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  avatarrequestmessage_ = const_cast< ::AvatarRequestMessage*>(
      ::AvatarRequestMessage::internal_default_instance());
#else
  avatarrequestmessage_ = const_cast< ::AvatarRequestMessage*>(&::AvatarRequestMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  avatarheadermessage_ = const_cast< ::AvatarHeaderMessage*>(
      ::AvatarHeaderMessage::internal_default_instance());
#else
  avatarheadermessage_ = const_cast< ::AvatarHeaderMessage*>(&::AvatarHeaderMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  avatardatamessage_ = const_cast< ::AvatarDataMessage*>(
      ::AvatarDataMessage::internal_default_instance());
#else
  avatardatamessage_ = const_cast< ::AvatarDataMessage*>(&::AvatarDataMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  avatarendmessage_ = const_cast< ::AvatarEndMessage*>(
      ::AvatarEndMessage::internal_default_instance());
#else
  avatarendmessage_ = const_cast< ::AvatarEndMessage*>(&::AvatarEndMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  unknownavatarmessage_ = const_cast< ::UnknownAvatarMessage*>(
      ::UnknownAvatarMessage::internal_default_instance());
#else
  unknownavatarmessage_ = const_cast< ::UnknownAvatarMessage*>(&::UnknownAvatarMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  playerlistmessage_ = const_cast< ::PlayerListMessage*>(
      ::PlayerListMessage::internal_default_instance());
#else
  playerlistmessage_ = const_cast< ::PlayerListMessage*>(&::PlayerListMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamelistnewmessage_ = const_cast< ::GameListNewMessage*>(
      ::GameListNewMessage::internal_default_instance());
#else
  gamelistnewmessage_ = const_cast< ::GameListNewMessage*>(&::GameListNewMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamelistupdatemessage_ = const_cast< ::GameListUpdateMessage*>(
      ::GameListUpdateMessage::internal_default_instance());
#else
  gamelistupdatemessage_ = const_cast< ::GameListUpdateMessage*>(&::GameListUpdateMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamelistplayerjoinedmessage_ = const_cast< ::GameListPlayerJoinedMessage*>(
      ::GameListPlayerJoinedMessage::internal_default_instance());
#else
  gamelistplayerjoinedmessage_ = const_cast< ::GameListPlayerJoinedMessage*>(&::GameListPlayerJoinedMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamelistplayerleftmessage_ = const_cast< ::GameListPlayerLeftMessage*>(
      ::GameListPlayerLeftMessage::internal_default_instance());
#else
  gamelistplayerleftmessage_ = const_cast< ::GameListPlayerLeftMessage*>(&::GameListPlayerLeftMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamelistadminchangedmessage_ = const_cast< ::GameListAdminChangedMessage*>(
      ::GameListAdminChangedMessage::internal_default_instance());
#else
  gamelistadminchangedmessage_ = const_cast< ::GameListAdminChangedMessage*>(&::GameListAdminChangedMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  playerinforequestmessage_ = const_cast< ::PlayerInfoRequestMessage*>(
      ::PlayerInfoRequestMessage::internal_default_instance());
#else
  playerinforequestmessage_ = const_cast< ::PlayerInfoRequestMessage*>(&::PlayerInfoRequestMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  playerinforeplymessage_ = const_cast< ::PlayerInfoReplyMessage*>(
      ::PlayerInfoReplyMessage::internal_default_instance());
#else
  playerinforeplymessage_ = const_cast< ::PlayerInfoReplyMessage*>(&::PlayerInfoReplyMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  subscriptionrequestmessage_ = const_cast< ::SubscriptionRequestMessage*>(
      ::SubscriptionRequestMessage::internal_default_instance());
#else
  subscriptionrequestmessage_ = const_cast< ::SubscriptionRequestMessage*>(&::SubscriptionRequestMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  joinexistinggamemessage_ = const_cast< ::JoinExistingGameMessage*>(
      ::JoinExistingGameMessage::internal_default_instance());
#else
  joinexistinggamemessage_ = const_cast< ::JoinExistingGameMessage*>(&::JoinExistingGameMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  joinnewgamemessage_ = const_cast< ::JoinNewGameMessage*>(
      ::JoinNewGameMessage::internal_default_instance());
#else
  joinnewgamemessage_ = const_cast< ::JoinNewGameMessage*>(&::JoinNewGameMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  rejoinexistinggamemessage_ = const_cast< ::RejoinExistingGameMessage*>(
      ::RejoinExistingGameMessage::internal_default_instance());
#else
  rejoinexistinggamemessage_ = const_cast< ::RejoinExistingGameMessage*>(&::RejoinExistingGameMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  joingameackmessage_ = const_cast< ::JoinGameAckMessage*>(
      ::JoinGameAckMessage::internal_default_instance());
#else
  joingameackmessage_ = const_cast< ::JoinGameAckMessage*>(&::JoinGameAckMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  joingamefailedmessage_ = const_cast< ::JoinGameFailedMessage*>(
      ::JoinGameFailedMessage::internal_default_instance());
#else
  joingamefailedmessage_ = const_cast< ::JoinGameFailedMessage*>(&::JoinGameFailedMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gameplayerjoinedmessage_ = const_cast< ::GamePlayerJoinedMessage*>(
      ::GamePlayerJoinedMessage::internal_default_instance());
#else
  gameplayerjoinedmessage_ = const_cast< ::GamePlayerJoinedMessage*>(&::GamePlayerJoinedMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gameplayerleftmessage_ = const_cast< ::GamePlayerLeftMessage*>(
      ::GamePlayerLeftMessage::internal_default_instance());
#else
  gameplayerleftmessage_ = const_cast< ::GamePlayerLeftMessage*>(&::GamePlayerLeftMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gameadminchangedmessage_ = const_cast< ::GameAdminChangedMessage*>(
      ::GameAdminChangedMessage::internal_default_instance());
#else
  gameadminchangedmessage_ = const_cast< ::GameAdminChangedMessage*>(&::GameAdminChangedMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  removedfromgamemessage_ = const_cast< ::RemovedFromGameMessage*>(
      ::RemovedFromGameMessage::internal_default_instance());
#else
  removedfromgamemessage_ = const_cast< ::RemovedFromGameMessage*>(&::RemovedFromGameMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  kickplayerrequestmessage_ = const_cast< ::KickPlayerRequestMessage*>(
      ::KickPlayerRequestMessage::internal_default_instance());
#else
  kickplayerrequestmessage_ = const_cast< ::KickPlayerRequestMessage*>(&::KickPlayerRequestMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  leavegamerequestmessage_ = const_cast< ::LeaveGameRequestMessage*>(
      ::LeaveGameRequestMessage::internal_default_instance());
#else
  leavegamerequestmessage_ = const_cast< ::LeaveGameRequestMessage*>(&::LeaveGameRequestMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  inviteplayertogamemessage_ = const_cast< ::InvitePlayerToGameMessage*>(
      ::InvitePlayerToGameMessage::internal_default_instance());
#else
  inviteplayertogamemessage_ = const_cast< ::InvitePlayerToGameMessage*>(&::InvitePlayerToGameMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  invitenotifymessage_ = const_cast< ::InviteNotifyMessage*>(
      ::InviteNotifyMessage::internal_default_instance());
#else
  invitenotifymessage_ = const_cast< ::InviteNotifyMessage*>(&::InviteNotifyMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  rejectgameinvitationmessage_ = const_cast< ::RejectGameInvitationMessage*>(
      ::RejectGameInvitationMessage::internal_default_instance());
#else
  rejectgameinvitationmessage_ = const_cast< ::RejectGameInvitationMessage*>(&::RejectGameInvitationMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  rejectinvnotifymessage_ = const_cast< ::RejectInvNotifyMessage*>(
      ::RejectInvNotifyMessage::internal_default_instance());
#else
  rejectinvnotifymessage_ = const_cast< ::RejectInvNotifyMessage*>(&::RejectInvNotifyMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  starteventmessage_ = const_cast< ::StartEventMessage*>(
      ::StartEventMessage::internal_default_instance());
#else
  starteventmessage_ = const_cast< ::StartEventMessage*>(&::StartEventMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  starteventackmessage_ = const_cast< ::StartEventAckMessage*>(
      ::StartEventAckMessage::internal_default_instance());
#else
  starteventackmessage_ = const_cast< ::StartEventAckMessage*>(&::StartEventAckMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamestartinitialmessage_ = const_cast< ::GameStartInitialMessage*>(
      ::GameStartInitialMessage::internal_default_instance());
#else
  gamestartinitialmessage_ = const_cast< ::GameStartInitialMessage*>(&::GameStartInitialMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamestartrejoinmessage_ = const_cast< ::GameStartRejoinMessage*>(
      ::GameStartRejoinMessage::internal_default_instance());
#else
  gamestartrejoinmessage_ = const_cast< ::GameStartRejoinMessage*>(&::GameStartRejoinMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  handstartmessage_ = const_cast< ::HandStartMessage*>(
      ::HandStartMessage::internal_default_instance());
#else
  handstartmessage_ = const_cast< ::HandStartMessage*>(&::HandStartMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  playersturnmessage_ = const_cast< ::PlayersTurnMessage*>(
      ::PlayersTurnMessage::internal_default_instance());
#else
  playersturnmessage_ = const_cast< ::PlayersTurnMessage*>(&::PlayersTurnMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  myactionrequestmessage_ = const_cast< ::MyActionRequestMessage*>(
      ::MyActionRequestMessage::internal_default_instance());
#else
  myactionrequestmessage_ = const_cast< ::MyActionRequestMessage*>(&::MyActionRequestMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  youractionrejectedmessage_ = const_cast< ::YourActionRejectedMessage*>(
      ::YourActionRejectedMessage::internal_default_instance());
#else
  youractionrejectedmessage_ = const_cast< ::YourActionRejectedMessage*>(&::YourActionRejectedMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  playersactiondonemessage_ = const_cast< ::PlayersActionDoneMessage*>(
      ::PlayersActionDoneMessage::internal_default_instance());
#else
  playersactiondonemessage_ = const_cast< ::PlayersActionDoneMessage*>(&::PlayersActionDoneMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  dealflopcardsmessage_ = const_cast< ::DealFlopCardsMessage*>(
      ::DealFlopCardsMessage::internal_default_instance());
#else
  dealflopcardsmessage_ = const_cast< ::DealFlopCardsMessage*>(&::DealFlopCardsMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  dealturncardmessage_ = const_cast< ::DealTurnCardMessage*>(
      ::DealTurnCardMessage::internal_default_instance());
#else
  dealturncardmessage_ = const_cast< ::DealTurnCardMessage*>(&::DealTurnCardMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  dealrivercardmessage_ = const_cast< ::DealRiverCardMessage*>(
      ::DealRiverCardMessage::internal_default_instance());
#else
  dealrivercardmessage_ = const_cast< ::DealRiverCardMessage*>(&::DealRiverCardMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  allinshowcardsmessage_ = const_cast< ::AllInShowCardsMessage*>(
      ::AllInShowCardsMessage::internal_default_instance());
#else
  allinshowcardsmessage_ = const_cast< ::AllInShowCardsMessage*>(&::AllInShowCardsMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  endofhandshowcardsmessage_ = const_cast< ::EndOfHandShowCardsMessage*>(
      ::EndOfHandShowCardsMessage::internal_default_instance());
#else
  endofhandshowcardsmessage_ = const_cast< ::EndOfHandShowCardsMessage*>(&::EndOfHandShowCardsMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  endofhandhidecardsmessage_ = const_cast< ::EndOfHandHideCardsMessage*>(
      ::EndOfHandHideCardsMessage::internal_default_instance());
#else
  endofhandhidecardsmessage_ = const_cast< ::EndOfHandHideCardsMessage*>(&::EndOfHandHideCardsMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  showmycardsrequestmessage_ = const_cast< ::ShowMyCardsRequestMessage*>(
      ::ShowMyCardsRequestMessage::internal_default_instance());
#else
  showmycardsrequestmessage_ = const_cast< ::ShowMyCardsRequestMessage*>(&::ShowMyCardsRequestMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  afterhandshowcardsmessage_ = const_cast< ::AfterHandShowCardsMessage*>(
      ::AfterHandShowCardsMessage::internal_default_instance());
#else
  afterhandshowcardsmessage_ = const_cast< ::AfterHandShowCardsMessage*>(&::AfterHandShowCardsMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  endofgamemessage_ = const_cast< ::EndOfGameMessage*>(
      ::EndOfGameMessage::internal_default_instance());
#else
  endofgamemessage_ = const_cast< ::EndOfGameMessage*>(&::EndOfGameMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  playeridchangedmessage_ = const_cast< ::PlayerIdChangedMessage*>(
      ::PlayerIdChangedMessage::internal_default_instance());
#else
  playeridchangedmessage_ = const_cast< ::PlayerIdChangedMessage*>(&::PlayerIdChangedMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  askkickplayermessage_ = const_cast< ::AskKickPlayerMessage*>(
      ::AskKickPlayerMessage::internal_default_instance());
#else
  askkickplayermessage_ = const_cast< ::AskKickPlayerMessage*>(&::AskKickPlayerMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  askkickdeniedmessage_ = const_cast< ::AskKickDeniedMessage*>(
      ::AskKickDeniedMessage::internal_default_instance());
#else
  askkickdeniedmessage_ = const_cast< ::AskKickDeniedMessage*>(&::AskKickDeniedMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  startkickpetitionmessage_ = const_cast< ::StartKickPetitionMessage*>(
      ::StartKickPetitionMessage::internal_default_instance());
#else
  startkickpetitionmessage_ = const_cast< ::StartKickPetitionMessage*>(&::StartKickPetitionMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  votekickrequestmessage_ = const_cast< ::VoteKickRequestMessage*>(
      ::VoteKickRequestMessage::internal_default_instance());
#else
  votekickrequestmessage_ = const_cast< ::VoteKickRequestMessage*>(&::VoteKickRequestMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  votekickreplymessage_ = const_cast< ::VoteKickReplyMessage*>(
      ::VoteKickReplyMessage::internal_default_instance());
#else
  votekickreplymessage_ = const_cast< ::VoteKickReplyMessage*>(&::VoteKickReplyMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  kickpetitionupdatemessage_ = const_cast< ::KickPetitionUpdateMessage*>(
      ::KickPetitionUpdateMessage::internal_default_instance());
#else
  kickpetitionupdatemessage_ = const_cast< ::KickPetitionUpdateMessage*>(&::KickPetitionUpdateMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  endkickpetitionmessage_ = const_cast< ::EndKickPetitionMessage*>(
      ::EndKickPetitionMessage::internal_default_instance());
#else
  endkickpetitionmessage_ = const_cast< ::EndKickPetitionMessage*>(&::EndKickPetitionMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  statisticsmessage_ = const_cast< ::StatisticsMessage*>(
      ::StatisticsMessage::internal_default_instance());
#else
  statisticsmessage_ = const_cast< ::StatisticsMessage*>(&::StatisticsMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  chatrequestmessage_ = const_cast< ::ChatRequestMessage*>(
      ::ChatRequestMessage::internal_default_instance());
#else
  chatrequestmessage_ = const_cast< ::ChatRequestMessage*>(&::ChatRequestMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  chatmessage_ = const_cast< ::ChatMessage*>(
      ::ChatMessage::internal_default_instance());
#else
  chatmessage_ = const_cast< ::ChatMessage*>(&::ChatMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  chatrejectmessage_ = const_cast< ::ChatRejectMessage*>(
      ::ChatRejectMessage::internal_default_instance());
#else
  chatrejectmessage_ = const_cast< ::ChatRejectMessage*>(&::ChatRejectMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  dialogmessage_ = const_cast< ::DialogMessage*>(
      ::DialogMessage::internal_default_instance());
#else
  dialogmessage_ = const_cast< ::DialogMessage*>(&::DialogMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  timeoutwarningmessage_ = const_cast< ::TimeoutWarningMessage*>(
      ::TimeoutWarningMessage::internal_default_instance());
#else
  timeoutwarningmessage_ = const_cast< ::TimeoutWarningMessage*>(&::TimeoutWarningMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  resettimeoutmessage_ = const_cast< ::ResetTimeoutMessage*>(
      ::ResetTimeoutMessage::internal_default_instance());
#else
  resettimeoutmessage_ = const_cast< ::ResetTimeoutMessage*>(&::ResetTimeoutMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  reportavatarmessage_ = const_cast< ::ReportAvatarMessage*>(
      ::ReportAvatarMessage::internal_default_instance());
#else
  reportavatarmessage_ = const_cast< ::ReportAvatarMessage*>(&::ReportAvatarMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  reportavatarackmessage_ = const_cast< ::ReportAvatarAckMessage*>(
      ::ReportAvatarAckMessage::internal_default_instance());
#else
  reportavatarackmessage_ = const_cast< ::ReportAvatarAckMessage*>(&::ReportAvatarAckMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  reportgamemessage_ = const_cast< ::ReportGameMessage*>(
      ::ReportGameMessage::internal_default_instance());
#else
  reportgamemessage_ = const_cast< ::ReportGameMessage*>(&::ReportGameMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  reportgameackmessage_ = const_cast< ::ReportGameAckMessage*>(
      ::ReportGameAckMessage::internal_default_instance());
#else
  reportgameackmessage_ = const_cast< ::ReportGameAckMessage*>(&::ReportGameAckMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  errormessage_ = const_cast< ::ErrorMessage*>(
      ::ErrorMessage::internal_default_instance());
#else
  errormessage_ = const_cast< ::ErrorMessage*>(&::ErrorMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  adminremovegamemessage_ = const_cast< ::AdminRemoveGameMessage*>(
      ::AdminRemoveGameMessage::internal_default_instance());
#else
  adminremovegamemessage_ = const_cast< ::AdminRemoveGameMessage*>(&::AdminRemoveGameMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  adminremovegameackmessage_ = const_cast< ::AdminRemoveGameAckMessage*>(
      ::AdminRemoveGameAckMessage::internal_default_instance());
#else
  adminremovegameackmessage_ = const_cast< ::AdminRemoveGameAckMessage*>(&::AdminRemoveGameAckMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  adminbanplayermessage_ = const_cast< ::AdminBanPlayerMessage*>(
      ::AdminBanPlayerMessage::internal_default_instance());
#else
  adminbanplayermessage_ = const_cast< ::AdminBanPlayerMessage*>(&::AdminBanPlayerMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  adminbanplayerackmessage_ = const_cast< ::AdminBanPlayerAckMessage*>(
      ::AdminBanPlayerAckMessage::internal_default_instance());
#else
  adminbanplayerackmessage_ = const_cast< ::AdminBanPlayerAckMessage*>(&::AdminBanPlayerAckMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamelistspectatorjoinedmessage_ = const_cast< ::GameListSpectatorJoinedMessage*>(
      ::GameListSpectatorJoinedMessage::internal_default_instance());
#else
  gamelistspectatorjoinedmessage_ = const_cast< ::GameListSpectatorJoinedMessage*>(&::GameListSpectatorJoinedMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamelistspectatorleftmessage_ = const_cast< ::GameListSpectatorLeftMessage*>(
      ::GameListSpectatorLeftMessage::internal_default_instance());
#else
  gamelistspectatorleftmessage_ = const_cast< ::GameListSpectatorLeftMessage*>(&::GameListSpectatorLeftMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamespectatorjoinedmessage_ = const_cast< ::GameSpectatorJoinedMessage*>(
      ::GameSpectatorJoinedMessage::internal_default_instance());
#else
  gamespectatorjoinedmessage_ = const_cast< ::GameSpectatorJoinedMessage*>(&::GameSpectatorJoinedMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  gamespectatorleftmessage_ = const_cast< ::GameSpectatorLeftMessage*>(
      ::GameSpectatorLeftMessage::internal_default_instance());
#else
  gamespectatorleftmessage_ = const_cast< ::GameSpectatorLeftMessage*>(&::GameSpectatorLeftMessage::default_instance());
#endif
}

PokerTHMessage::PokerTHMessage(const PokerTHMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PokerTHMessage)
}

void PokerTHMessage::SharedCtor() {
  _cached_size_ = 0;
  messagetype_ = 1;
  announcemessage_ = NULL;
  initmessage_ = NULL;
  authserverchallengemessage_ = NULL;
  authclientresponsemessage_ = NULL;
  authserververificationmessage_ = NULL;
  initackmessage_ = NULL;
  avatarrequestmessage_ = NULL;
  avatarheadermessage_ = NULL;
  avatardatamessage_ = NULL;
  avatarendmessage_ = NULL;
  unknownavatarmessage_ = NULL;
  playerlistmessage_ = NULL;
  gamelistnewmessage_ = NULL;
  gamelistupdatemessage_ = NULL;
  gamelistplayerjoinedmessage_ = NULL;
  gamelistplayerleftmessage_ = NULL;
  gamelistadminchangedmessage_ = NULL;
  playerinforequestmessage_ = NULL;
  playerinforeplymessage_ = NULL;
  subscriptionrequestmessage_ = NULL;
  joinexistinggamemessage_ = NULL;
  joinnewgamemessage_ = NULL;
  rejoinexistinggamemessage_ = NULL;
  joingameackmessage_ = NULL;
  joingamefailedmessage_ = NULL;
  gameplayerjoinedmessage_ = NULL;
  gameplayerleftmessage_ = NULL;
  gameadminchangedmessage_ = NULL;
  removedfromgamemessage_ = NULL;
  kickplayerrequestmessage_ = NULL;
  leavegamerequestmessage_ = NULL;
  inviteplayertogamemessage_ = NULL;
  invitenotifymessage_ = NULL;
  rejectgameinvitationmessage_ = NULL;
  rejectinvnotifymessage_ = NULL;
  starteventmessage_ = NULL;
  starteventackmessage_ = NULL;
  gamestartinitialmessage_ = NULL;
  gamestartrejoinmessage_ = NULL;
  handstartmessage_ = NULL;
  playersturnmessage_ = NULL;
  myactionrequestmessage_ = NULL;
  youractionrejectedmessage_ = NULL;
  playersactiondonemessage_ = NULL;
  dealflopcardsmessage_ = NULL;
  dealturncardmessage_ = NULL;
  dealrivercardmessage_ = NULL;
  allinshowcardsmessage_ = NULL;
  endofhandshowcardsmessage_ = NULL;
  endofhandhidecardsmessage_ = NULL;
  showmycardsrequestmessage_ = NULL;
  afterhandshowcardsmessage_ = NULL;
  endofgamemessage_ = NULL;
  playeridchangedmessage_ = NULL;
  askkickplayermessage_ = NULL;
  askkickdeniedmessage_ = NULL;
  startkickpetitionmessage_ = NULL;
  votekickrequestmessage_ = NULL;
  votekickreplymessage_ = NULL;
  kickpetitionupdatemessage_ = NULL;
  endkickpetitionmessage_ = NULL;
  statisticsmessage_ = NULL;
  chatrequestmessage_ = NULL;
  chatmessage_ = NULL;
  chatrejectmessage_ = NULL;
  dialogmessage_ = NULL;
  timeoutwarningmessage_ = NULL;
  resettimeoutmessage_ = NULL;
  reportavatarmessage_ = NULL;
  reportavatarackmessage_ = NULL;
  reportgamemessage_ = NULL;
  reportgameackmessage_ = NULL;
  errormessage_ = NULL;
  adminremovegamemessage_ = NULL;
  adminremovegameackmessage_ = NULL;
  adminbanplayermessage_ = NULL;
  adminbanplayerackmessage_ = NULL;
  gamelistspectatorjoinedmessage_ = NULL;
  gamelistspectatorleftmessage_ = NULL;
  gamespectatorjoinedmessage_ = NULL;
  gamespectatorleftmessage_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PokerTHMessage::~PokerTHMessage() {
  // @@protoc_insertion_point(destructor:PokerTHMessage)
  SharedDtor();
}

void PokerTHMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete announcemessage_;
    delete initmessage_;
    delete authserverchallengemessage_;
    delete authclientresponsemessage_;
    delete authserververificationmessage_;
    delete initackmessage_;
    delete avatarrequestmessage_;
    delete avatarheadermessage_;
    delete avatardatamessage_;
    delete avatarendmessage_;
    delete unknownavatarmessage_;
    delete playerlistmessage_;
    delete gamelistnewmessage_;
    delete gamelistupdatemessage_;
    delete gamelistplayerjoinedmessage_;
    delete gamelistplayerleftmessage_;
    delete gamelistadminchangedmessage_;
    delete playerinforequestmessage_;
    delete playerinforeplymessage_;
    delete subscriptionrequestmessage_;
    delete joinexistinggamemessage_;
    delete joinnewgamemessage_;
    delete rejoinexistinggamemessage_;
    delete joingameackmessage_;
    delete joingamefailedmessage_;
    delete gameplayerjoinedmessage_;
    delete gameplayerleftmessage_;
    delete gameadminchangedmessage_;
    delete removedfromgamemessage_;
    delete kickplayerrequestmessage_;
    delete leavegamerequestmessage_;
    delete inviteplayertogamemessage_;
    delete invitenotifymessage_;
    delete rejectgameinvitationmessage_;
    delete rejectinvnotifymessage_;
    delete starteventmessage_;
    delete starteventackmessage_;
    delete gamestartinitialmessage_;
    delete gamestartrejoinmessage_;
    delete handstartmessage_;
    delete playersturnmessage_;
    delete myactionrequestmessage_;
    delete youractionrejectedmessage_;
    delete playersactiondonemessage_;
    delete dealflopcardsmessage_;
    delete dealturncardmessage_;
    delete dealrivercardmessage_;
    delete allinshowcardsmessage_;
    delete endofhandshowcardsmessage_;
    delete endofhandhidecardsmessage_;
    delete showmycardsrequestmessage_;
    delete afterhandshowcardsmessage_;
    delete endofgamemessage_;
    delete playeridchangedmessage_;
    delete askkickplayermessage_;
    delete askkickdeniedmessage_;
    delete startkickpetitionmessage_;
    delete votekickrequestmessage_;
    delete votekickreplymessage_;
    delete kickpetitionupdatemessage_;
    delete endkickpetitionmessage_;
    delete statisticsmessage_;
    delete chatrequestmessage_;
    delete chatmessage_;
    delete chatrejectmessage_;
    delete dialogmessage_;
    delete timeoutwarningmessage_;
    delete resettimeoutmessage_;
    delete reportavatarmessage_;
    delete reportavatarackmessage_;
    delete reportgamemessage_;
    delete reportgameackmessage_;
    delete errormessage_;
    delete adminremovegamemessage_;
    delete adminremovegameackmessage_;
    delete adminbanplayermessage_;
    delete adminbanplayerackmessage_;
    delete gamelistspectatorjoinedmessage_;
    delete gamelistspectatorleftmessage_;
    delete gamespectatorjoinedmessage_;
    delete gamespectatorleftmessage_;
  }
}

void PokerTHMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PokerTHMessage& PokerTHMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_pokerth_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_pokerth_2eproto();
#endif
  return *default_instance_;
}

PokerTHMessage* PokerTHMessage::default_instance_ = NULL;

PokerTHMessage* PokerTHMessage::New() const {
  return new PokerTHMessage;
}

void PokerTHMessage::Clear() {
  if (_has_bits_[0 / 32] & 255) {
    messagetype_ = 1;
    if (has_announcemessage()) {
      if (announcemessage_ != NULL) announcemessage_->::AnnounceMessage::Clear();
    }
    if (has_initmessage()) {
      if (initmessage_ != NULL) initmessage_->::InitMessage::Clear();
    }
    if (has_authserverchallengemessage()) {
      if (authserverchallengemessage_ != NULL) authserverchallengemessage_->::AuthServerChallengeMessage::Clear();
    }
    if (has_authclientresponsemessage()) {
      if (authclientresponsemessage_ != NULL) authclientresponsemessage_->::AuthClientResponseMessage::Clear();
    }
    if (has_authserververificationmessage()) {
      if (authserververificationmessage_ != NULL) authserververificationmessage_->::AuthServerVerificationMessage::Clear();
    }
    if (has_initackmessage()) {
      if (initackmessage_ != NULL) initackmessage_->::InitAckMessage::Clear();
    }
    if (has_avatarrequestmessage()) {
      if (avatarrequestmessage_ != NULL) avatarrequestmessage_->::AvatarRequestMessage::Clear();
    }
  }
  if (_has_bits_[8 / 32] & 65280) {
    if (has_avatarheadermessage()) {
      if (avatarheadermessage_ != NULL) avatarheadermessage_->::AvatarHeaderMessage::Clear();
    }
    if (has_avatardatamessage()) {
      if (avatardatamessage_ != NULL) avatardatamessage_->::AvatarDataMessage::Clear();
    }
    if (has_avatarendmessage()) {
      if (avatarendmessage_ != NULL) avatarendmessage_->::AvatarEndMessage::Clear();
    }
    if (has_unknownavatarmessage()) {
      if (unknownavatarmessage_ != NULL) unknownavatarmessage_->::UnknownAvatarMessage::Clear();
    }
    if (has_playerlistmessage()) {
      if (playerlistmessage_ != NULL) playerlistmessage_->::PlayerListMessage::Clear();
    }
    if (has_gamelistnewmessage()) {
      if (gamelistnewmessage_ != NULL) gamelistnewmessage_->::GameListNewMessage::Clear();
    }
    if (has_gamelistupdatemessage()) {
      if (gamelistupdatemessage_ != NULL) gamelistupdatemessage_->::GameListUpdateMessage::Clear();
    }
    if (has_gamelistplayerjoinedmessage()) {
      if (gamelistplayerjoinedmessage_ != NULL) gamelistplayerjoinedmessage_->::GameListPlayerJoinedMessage::Clear();
    }
  }
  if (_has_bits_[16 / 32] & 16711680) {
    if (has_gamelistplayerleftmessage()) {
      if (gamelistplayerleftmessage_ != NULL) gamelistplayerleftmessage_->::GameListPlayerLeftMessage::Clear();
    }
    if (has_gamelistadminchangedmessage()) {
      if (gamelistadminchangedmessage_ != NULL) gamelistadminchangedmessage_->::GameListAdminChangedMessage::Clear();
    }
    if (has_playerinforequestmessage()) {
      if (playerinforequestmessage_ != NULL) playerinforequestmessage_->::PlayerInfoRequestMessage::Clear();
    }
    if (has_playerinforeplymessage()) {
      if (playerinforeplymessage_ != NULL) playerinforeplymessage_->::PlayerInfoReplyMessage::Clear();
    }
    if (has_subscriptionrequestmessage()) {
      if (subscriptionrequestmessage_ != NULL) subscriptionrequestmessage_->::SubscriptionRequestMessage::Clear();
    }
    if (has_joinexistinggamemessage()) {
      if (joinexistinggamemessage_ != NULL) joinexistinggamemessage_->::JoinExistingGameMessage::Clear();
    }
    if (has_joinnewgamemessage()) {
      if (joinnewgamemessage_ != NULL) joinnewgamemessage_->::JoinNewGameMessage::Clear();
    }
    if (has_rejoinexistinggamemessage()) {
      if (rejoinexistinggamemessage_ != NULL) rejoinexistinggamemessage_->::RejoinExistingGameMessage::Clear();
    }
  }
  if (_has_bits_[24 / 32] & 4278190080) {
    if (has_joingameackmessage()) {
      if (joingameackmessage_ != NULL) joingameackmessage_->::JoinGameAckMessage::Clear();
    }
    if (has_joingamefailedmessage()) {
      if (joingamefailedmessage_ != NULL) joingamefailedmessage_->::JoinGameFailedMessage::Clear();
    }
    if (has_gameplayerjoinedmessage()) {
      if (gameplayerjoinedmessage_ != NULL) gameplayerjoinedmessage_->::GamePlayerJoinedMessage::Clear();
    }
    if (has_gameplayerleftmessage()) {
      if (gameplayerleftmessage_ != NULL) gameplayerleftmessage_->::GamePlayerLeftMessage::Clear();
    }
    if (has_gameadminchangedmessage()) {
      if (gameadminchangedmessage_ != NULL) gameadminchangedmessage_->::GameAdminChangedMessage::Clear();
    }
    if (has_removedfromgamemessage()) {
      if (removedfromgamemessage_ != NULL) removedfromgamemessage_->::RemovedFromGameMessage::Clear();
    }
    if (has_kickplayerrequestmessage()) {
      if (kickplayerrequestmessage_ != NULL) kickplayerrequestmessage_->::KickPlayerRequestMessage::Clear();
    }
    if (has_leavegamerequestmessage()) {
      if (leavegamerequestmessage_ != NULL) leavegamerequestmessage_->::LeaveGameRequestMessage::Clear();
    }
  }
  if (_has_bits_[32 / 32] & 255) {
    if (has_inviteplayertogamemessage()) {
      if (inviteplayertogamemessage_ != NULL) inviteplayertogamemessage_->::InvitePlayerToGameMessage::Clear();
    }
    if (has_invitenotifymessage()) {
      if (invitenotifymessage_ != NULL) invitenotifymessage_->::InviteNotifyMessage::Clear();
    }
    if (has_rejectgameinvitationmessage()) {
      if (rejectgameinvitationmessage_ != NULL) rejectgameinvitationmessage_->::RejectGameInvitationMessage::Clear();
    }
    if (has_rejectinvnotifymessage()) {
      if (rejectinvnotifymessage_ != NULL) rejectinvnotifymessage_->::RejectInvNotifyMessage::Clear();
    }
    if (has_starteventmessage()) {
      if (starteventmessage_ != NULL) starteventmessage_->::StartEventMessage::Clear();
    }
    if (has_starteventackmessage()) {
      if (starteventackmessage_ != NULL) starteventackmessage_->::StartEventAckMessage::Clear();
    }
    if (has_gamestartinitialmessage()) {
      if (gamestartinitialmessage_ != NULL) gamestartinitialmessage_->::GameStartInitialMessage::Clear();
    }
    if (has_gamestartrejoinmessage()) {
      if (gamestartrejoinmessage_ != NULL) gamestartrejoinmessage_->::GameStartRejoinMessage::Clear();
    }
  }
  if (_has_bits_[40 / 32] & 65280) {
    if (has_handstartmessage()) {
      if (handstartmessage_ != NULL) handstartmessage_->::HandStartMessage::Clear();
    }
    if (has_playersturnmessage()) {
      if (playersturnmessage_ != NULL) playersturnmessage_->::PlayersTurnMessage::Clear();
    }
    if (has_myactionrequestmessage()) {
      if (myactionrequestmessage_ != NULL) myactionrequestmessage_->::MyActionRequestMessage::Clear();
    }
    if (has_youractionrejectedmessage()) {
      if (youractionrejectedmessage_ != NULL) youractionrejectedmessage_->::YourActionRejectedMessage::Clear();
    }
    if (has_playersactiondonemessage()) {
      if (playersactiondonemessage_ != NULL) playersactiondonemessage_->::PlayersActionDoneMessage::Clear();
    }
    if (has_dealflopcardsmessage()) {
      if (dealflopcardsmessage_ != NULL) dealflopcardsmessage_->::DealFlopCardsMessage::Clear();
    }
    if (has_dealturncardmessage()) {
      if (dealturncardmessage_ != NULL) dealturncardmessage_->::DealTurnCardMessage::Clear();
    }
    if (has_dealrivercardmessage()) {
      if (dealrivercardmessage_ != NULL) dealrivercardmessage_->::DealRiverCardMessage::Clear();
    }
  }
  if (_has_bits_[48 / 32] & 16711680) {
    if (has_allinshowcardsmessage()) {
      if (allinshowcardsmessage_ != NULL) allinshowcardsmessage_->::AllInShowCardsMessage::Clear();
    }
    if (has_endofhandshowcardsmessage()) {
      if (endofhandshowcardsmessage_ != NULL) endofhandshowcardsmessage_->::EndOfHandShowCardsMessage::Clear();
    }
    if (has_endofhandhidecardsmessage()) {
      if (endofhandhidecardsmessage_ != NULL) endofhandhidecardsmessage_->::EndOfHandHideCardsMessage::Clear();
    }
    if (has_showmycardsrequestmessage()) {
      if (showmycardsrequestmessage_ != NULL) showmycardsrequestmessage_->::ShowMyCardsRequestMessage::Clear();
    }
    if (has_afterhandshowcardsmessage()) {
      if (afterhandshowcardsmessage_ != NULL) afterhandshowcardsmessage_->::AfterHandShowCardsMessage::Clear();
    }
    if (has_endofgamemessage()) {
      if (endofgamemessage_ != NULL) endofgamemessage_->::EndOfGameMessage::Clear();
    }
    if (has_playeridchangedmessage()) {
      if (playeridchangedmessage_ != NULL) playeridchangedmessage_->::PlayerIdChangedMessage::Clear();
    }
    if (has_askkickplayermessage()) {
      if (askkickplayermessage_ != NULL) askkickplayermessage_->::AskKickPlayerMessage::Clear();
    }
  }
  if (_has_bits_[56 / 32] & 4278190080) {
    if (has_askkickdeniedmessage()) {
      if (askkickdeniedmessage_ != NULL) askkickdeniedmessage_->::AskKickDeniedMessage::Clear();
    }
    if (has_startkickpetitionmessage()) {
      if (startkickpetitionmessage_ != NULL) startkickpetitionmessage_->::StartKickPetitionMessage::Clear();
    }
    if (has_votekickrequestmessage()) {
      if (votekickrequestmessage_ != NULL) votekickrequestmessage_->::VoteKickRequestMessage::Clear();
    }
    if (has_votekickreplymessage()) {
      if (votekickreplymessage_ != NULL) votekickreplymessage_->::VoteKickReplyMessage::Clear();
    }
    if (has_kickpetitionupdatemessage()) {
      if (kickpetitionupdatemessage_ != NULL) kickpetitionupdatemessage_->::KickPetitionUpdateMessage::Clear();
    }
    if (has_endkickpetitionmessage()) {
      if (endkickpetitionmessage_ != NULL) endkickpetitionmessage_->::EndKickPetitionMessage::Clear();
    }
    if (has_statisticsmessage()) {
      if (statisticsmessage_ != NULL) statisticsmessage_->::StatisticsMessage::Clear();
    }
    if (has_chatrequestmessage()) {
      if (chatrequestmessage_ != NULL) chatrequestmessage_->::ChatRequestMessage::Clear();
    }
  }
  if (_has_bits_[64 / 32] & 255) {
    if (has_chatmessage()) {
      if (chatmessage_ != NULL) chatmessage_->::ChatMessage::Clear();
    }
    if (has_chatrejectmessage()) {
      if (chatrejectmessage_ != NULL) chatrejectmessage_->::ChatRejectMessage::Clear();
    }
    if (has_dialogmessage()) {
      if (dialogmessage_ != NULL) dialogmessage_->::DialogMessage::Clear();
    }
    if (has_timeoutwarningmessage()) {
      if (timeoutwarningmessage_ != NULL) timeoutwarningmessage_->::TimeoutWarningMessage::Clear();
    }
    if (has_resettimeoutmessage()) {
      if (resettimeoutmessage_ != NULL) resettimeoutmessage_->::ResetTimeoutMessage::Clear();
    }
    if (has_reportavatarmessage()) {
      if (reportavatarmessage_ != NULL) reportavatarmessage_->::ReportAvatarMessage::Clear();
    }
    if (has_reportavatarackmessage()) {
      if (reportavatarackmessage_ != NULL) reportavatarackmessage_->::ReportAvatarAckMessage::Clear();
    }
    if (has_reportgamemessage()) {
      if (reportgamemessage_ != NULL) reportgamemessage_->::ReportGameMessage::Clear();
    }
  }
  if (_has_bits_[72 / 32] & 65280) {
    if (has_reportgameackmessage()) {
      if (reportgameackmessage_ != NULL) reportgameackmessage_->::ReportGameAckMessage::Clear();
    }
    if (has_errormessage()) {
      if (errormessage_ != NULL) errormessage_->::ErrorMessage::Clear();
    }
    if (has_adminremovegamemessage()) {
      if (adminremovegamemessage_ != NULL) adminremovegamemessage_->::AdminRemoveGameMessage::Clear();
    }
    if (has_adminremovegameackmessage()) {
      if (adminremovegameackmessage_ != NULL) adminremovegameackmessage_->::AdminRemoveGameAckMessage::Clear();
    }
    if (has_adminbanplayermessage()) {
      if (adminbanplayermessage_ != NULL) adminbanplayermessage_->::AdminBanPlayerMessage::Clear();
    }
    if (has_adminbanplayerackmessage()) {
      if (adminbanplayerackmessage_ != NULL) adminbanplayerackmessage_->::AdminBanPlayerAckMessage::Clear();
    }
    if (has_gamelistspectatorjoinedmessage()) {
      if (gamelistspectatorjoinedmessage_ != NULL) gamelistspectatorjoinedmessage_->::GameListSpectatorJoinedMessage::Clear();
    }
    if (has_gamelistspectatorleftmessage()) {
      if (gamelistspectatorleftmessage_ != NULL) gamelistspectatorleftmessage_->::GameListSpectatorLeftMessage::Clear();
    }
  }
  if (_has_bits_[80 / 32] & 196608) {
    if (has_gamespectatorjoinedmessage()) {
      if (gamespectatorjoinedmessage_ != NULL) gamespectatorjoinedmessage_->::GameSpectatorJoinedMessage::Clear();
    }
    if (has_gamespectatorleftmessage()) {
      if (gamespectatorleftmessage_ != NULL) gamespectatorleftmessage_->::GameSpectatorLeftMessage::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PokerTHMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PokerTHMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .PokerTHMessage.PokerTHMessageType messageType = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::PokerTHMessage_PokerTHMessageType_IsValid(value)) {
            set_messagetype(static_cast< ::PokerTHMessage_PokerTHMessageType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_announceMessage;
        break;
      }

      // optional .AnnounceMessage announceMessage = 2;
      case 2: {
        if (tag == 18) {
         parse_announceMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_announcemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_initMessage;
        break;
      }

      // optional .InitMessage initMessage = 3;
      case 3: {
        if (tag == 26) {
         parse_initMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_initmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_authServerChallengeMessage;
        break;
      }

      // optional .AuthServerChallengeMessage authServerChallengeMessage = 4;
      case 4: {
        if (tag == 34) {
         parse_authServerChallengeMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_authserverchallengemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_authClientResponseMessage;
        break;
      }

      // optional .AuthClientResponseMessage authClientResponseMessage = 5;
      case 5: {
        if (tag == 42) {
         parse_authClientResponseMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_authclientresponsemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_authServerVerificationMessage;
        break;
      }

      // optional .AuthServerVerificationMessage authServerVerificationMessage = 6;
      case 6: {
        if (tag == 50) {
         parse_authServerVerificationMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_authserververificationmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_initAckMessage;
        break;
      }

      // optional .InitAckMessage initAckMessage = 7;
      case 7: {
        if (tag == 58) {
         parse_initAckMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_initackmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(66)) goto parse_avatarRequestMessage;
        break;
      }

      // optional .AvatarRequestMessage avatarRequestMessage = 8;
      case 8: {
        if (tag == 66) {
         parse_avatarRequestMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_avatarrequestmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(74)) goto parse_avatarHeaderMessage;
        break;
      }

      // optional .AvatarHeaderMessage avatarHeaderMessage = 9;
      case 9: {
        if (tag == 74) {
         parse_avatarHeaderMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_avatarheadermessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(82)) goto parse_avatarDataMessage;
        break;
      }

      // optional .AvatarDataMessage avatarDataMessage = 10;
      case 10: {
        if (tag == 82) {
         parse_avatarDataMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_avatardatamessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(90)) goto parse_avatarEndMessage;
        break;
      }

      // optional .AvatarEndMessage avatarEndMessage = 11;
      case 11: {
        if (tag == 90) {
         parse_avatarEndMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_avatarendmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(98)) goto parse_unknownAvatarMessage;
        break;
      }

      // optional .UnknownAvatarMessage unknownAvatarMessage = 12;
      case 12: {
        if (tag == 98) {
         parse_unknownAvatarMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_unknownavatarmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(106)) goto parse_playerListMessage;
        break;
      }

      // optional .PlayerListMessage playerListMessage = 13;
      case 13: {
        if (tag == 106) {
         parse_playerListMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_playerlistmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(114)) goto parse_gameListNewMessage;
        break;
      }

      // optional .GameListNewMessage gameListNewMessage = 14;
      case 14: {
        if (tag == 114) {
         parse_gameListNewMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamelistnewmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(122)) goto parse_gameListUpdateMessage;
        break;
      }

      // optional .GameListUpdateMessage gameListUpdateMessage = 15;
      case 15: {
        if (tag == 122) {
         parse_gameListUpdateMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamelistupdatemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(130)) goto parse_gameListPlayerJoinedMessage;
        break;
      }

      // optional .GameListPlayerJoinedMessage gameListPlayerJoinedMessage = 16;
      case 16: {
        if (tag == 130) {
         parse_gameListPlayerJoinedMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamelistplayerjoinedmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(138)) goto parse_gameListPlayerLeftMessage;
        break;
      }

      // optional .GameListPlayerLeftMessage gameListPlayerLeftMessage = 17;
      case 17: {
        if (tag == 138) {
         parse_gameListPlayerLeftMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamelistplayerleftmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(146)) goto parse_gameListAdminChangedMessage;
        break;
      }

      // optional .GameListAdminChangedMessage gameListAdminChangedMessage = 18;
      case 18: {
        if (tag == 146) {
         parse_gameListAdminChangedMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamelistadminchangedmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(154)) goto parse_playerInfoRequestMessage;
        break;
      }

      // optional .PlayerInfoRequestMessage playerInfoRequestMessage = 19;
      case 19: {
        if (tag == 154) {
         parse_playerInfoRequestMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_playerinforequestmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(162)) goto parse_playerInfoReplyMessage;
        break;
      }

      // optional .PlayerInfoReplyMessage playerInfoReplyMessage = 20;
      case 20: {
        if (tag == 162) {
         parse_playerInfoReplyMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_playerinforeplymessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(170)) goto parse_subscriptionRequestMessage;
        break;
      }

      // optional .SubscriptionRequestMessage subscriptionRequestMessage = 21;
      case 21: {
        if (tag == 170) {
         parse_subscriptionRequestMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_subscriptionrequestmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(178)) goto parse_joinExistingGameMessage;
        break;
      }

      // optional .JoinExistingGameMessage joinExistingGameMessage = 22;
      case 22: {
        if (tag == 178) {
         parse_joinExistingGameMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_joinexistinggamemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(186)) goto parse_joinNewGameMessage;
        break;
      }

      // optional .JoinNewGameMessage joinNewGameMessage = 23;
      case 23: {
        if (tag == 186) {
         parse_joinNewGameMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_joinnewgamemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(194)) goto parse_rejoinExistingGameMessage;
        break;
      }

      // optional .RejoinExistingGameMessage rejoinExistingGameMessage = 24;
      case 24: {
        if (tag == 194) {
         parse_rejoinExistingGameMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_rejoinexistinggamemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(202)) goto parse_joinGameAckMessage;
        break;
      }

      // optional .JoinGameAckMessage joinGameAckMessage = 25;
      case 25: {
        if (tag == 202) {
         parse_joinGameAckMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_joingameackmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(210)) goto parse_joinGameFailedMessage;
        break;
      }

      // optional .JoinGameFailedMessage joinGameFailedMessage = 26;
      case 26: {
        if (tag == 210) {
         parse_joinGameFailedMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_joingamefailedmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(218)) goto parse_gamePlayerJoinedMessage;
        break;
      }

      // optional .GamePlayerJoinedMessage gamePlayerJoinedMessage = 27;
      case 27: {
        if (tag == 218) {
         parse_gamePlayerJoinedMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gameplayerjoinedmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(226)) goto parse_gamePlayerLeftMessage;
        break;
      }

      // optional .GamePlayerLeftMessage gamePlayerLeftMessage = 28;
      case 28: {
        if (tag == 226) {
         parse_gamePlayerLeftMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gameplayerleftmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(234)) goto parse_gameAdminChangedMessage;
        break;
      }

      // optional .GameAdminChangedMessage gameAdminChangedMessage = 29;
      case 29: {
        if (tag == 234) {
         parse_gameAdminChangedMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gameadminchangedmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(242)) goto parse_removedFromGameMessage;
        break;
      }

      // optional .RemovedFromGameMessage removedFromGameMessage = 30;
      case 30: {
        if (tag == 242) {
         parse_removedFromGameMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_removedfromgamemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(250)) goto parse_kickPlayerRequestMessage;
        break;
      }

      // optional .KickPlayerRequestMessage kickPlayerRequestMessage = 31;
      case 31: {
        if (tag == 250) {
         parse_kickPlayerRequestMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_kickplayerrequestmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(258)) goto parse_leaveGameRequestMessage;
        break;
      }

      // optional .LeaveGameRequestMessage leaveGameRequestMessage = 32;
      case 32: {
        if (tag == 258) {
         parse_leaveGameRequestMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_leavegamerequestmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(266)) goto parse_invitePlayerToGameMessage;
        break;
      }

      // optional .InvitePlayerToGameMessage invitePlayerToGameMessage = 33;
      case 33: {
        if (tag == 266) {
         parse_invitePlayerToGameMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_inviteplayertogamemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(274)) goto parse_inviteNotifyMessage;
        break;
      }

      // optional .InviteNotifyMessage inviteNotifyMessage = 34;
      case 34: {
        if (tag == 274) {
         parse_inviteNotifyMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_invitenotifymessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(282)) goto parse_rejectGameInvitationMessage;
        break;
      }

      // optional .RejectGameInvitationMessage rejectGameInvitationMessage = 35;
      case 35: {
        if (tag == 282) {
         parse_rejectGameInvitationMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_rejectgameinvitationmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(290)) goto parse_rejectInvNotifyMessage;
        break;
      }

      // optional .RejectInvNotifyMessage rejectInvNotifyMessage = 36;
      case 36: {
        if (tag == 290) {
         parse_rejectInvNotifyMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_rejectinvnotifymessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(298)) goto parse_startEventMessage;
        break;
      }

      // optional .StartEventMessage startEventMessage = 37;
      case 37: {
        if (tag == 298) {
         parse_startEventMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_starteventmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(306)) goto parse_startEventAckMessage;
        break;
      }

      // optional .StartEventAckMessage startEventAckMessage = 38;
      case 38: {
        if (tag == 306) {
         parse_startEventAckMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_starteventackmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(314)) goto parse_gameStartInitialMessage;
        break;
      }

      // optional .GameStartInitialMessage gameStartInitialMessage = 39;
      case 39: {
        if (tag == 314) {
         parse_gameStartInitialMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamestartinitialmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(322)) goto parse_gameStartRejoinMessage;
        break;
      }

      // optional .GameStartRejoinMessage gameStartRejoinMessage = 40;
      case 40: {
        if (tag == 322) {
         parse_gameStartRejoinMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamestartrejoinmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(330)) goto parse_handStartMessage;
        break;
      }

      // optional .HandStartMessage handStartMessage = 41;
      case 41: {
        if (tag == 330) {
         parse_handStartMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_handstartmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(338)) goto parse_playersTurnMessage;
        break;
      }

      // optional .PlayersTurnMessage playersTurnMessage = 42;
      case 42: {
        if (tag == 338) {
         parse_playersTurnMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_playersturnmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(346)) goto parse_myActionRequestMessage;
        break;
      }

      // optional .MyActionRequestMessage myActionRequestMessage = 43;
      case 43: {
        if (tag == 346) {
         parse_myActionRequestMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_myactionrequestmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(354)) goto parse_yourActionRejectedMessage;
        break;
      }

      // optional .YourActionRejectedMessage yourActionRejectedMessage = 44;
      case 44: {
        if (tag == 354) {
         parse_yourActionRejectedMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_youractionrejectedmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(362)) goto parse_playersActionDoneMessage;
        break;
      }

      // optional .PlayersActionDoneMessage playersActionDoneMessage = 45;
      case 45: {
        if (tag == 362) {
         parse_playersActionDoneMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_playersactiondonemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(370)) goto parse_dealFlopCardsMessage;
        break;
      }

      // optional .DealFlopCardsMessage dealFlopCardsMessage = 46;
      case 46: {
        if (tag == 370) {
         parse_dealFlopCardsMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_dealflopcardsmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(378)) goto parse_dealTurnCardMessage;
        break;
      }

      // optional .DealTurnCardMessage dealTurnCardMessage = 47;
      case 47: {
        if (tag == 378) {
         parse_dealTurnCardMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_dealturncardmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(386)) goto parse_dealRiverCardMessage;
        break;
      }

      // optional .DealRiverCardMessage dealRiverCardMessage = 48;
      case 48: {
        if (tag == 386) {
         parse_dealRiverCardMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_dealrivercardmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(394)) goto parse_allInShowCardsMessage;
        break;
      }

      // optional .AllInShowCardsMessage allInShowCardsMessage = 49;
      case 49: {
        if (tag == 394) {
         parse_allInShowCardsMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_allinshowcardsmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(402)) goto parse_endOfHandShowCardsMessage;
        break;
      }

      // optional .EndOfHandShowCardsMessage endOfHandShowCardsMessage = 50;
      case 50: {
        if (tag == 402) {
         parse_endOfHandShowCardsMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_endofhandshowcardsmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(410)) goto parse_endOfHandHideCardsMessage;
        break;
      }

      // optional .EndOfHandHideCardsMessage endOfHandHideCardsMessage = 51;
      case 51: {
        if (tag == 410) {
         parse_endOfHandHideCardsMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_endofhandhidecardsmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(418)) goto parse_showMyCardsRequestMessage;
        break;
      }

      // optional .ShowMyCardsRequestMessage showMyCardsRequestMessage = 52;
      case 52: {
        if (tag == 418) {
         parse_showMyCardsRequestMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_showmycardsrequestmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(426)) goto parse_afterHandShowCardsMessage;
        break;
      }

      // optional .AfterHandShowCardsMessage afterHandShowCardsMessage = 53;
      case 53: {
        if (tag == 426) {
         parse_afterHandShowCardsMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_afterhandshowcardsmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(434)) goto parse_endOfGameMessage;
        break;
      }

      // optional .EndOfGameMessage endOfGameMessage = 54;
      case 54: {
        if (tag == 434) {
         parse_endOfGameMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_endofgamemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(442)) goto parse_playerIdChangedMessage;
        break;
      }

      // optional .PlayerIdChangedMessage playerIdChangedMessage = 55;
      case 55: {
        if (tag == 442) {
         parse_playerIdChangedMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_playeridchangedmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(450)) goto parse_askKickPlayerMessage;
        break;
      }

      // optional .AskKickPlayerMessage askKickPlayerMessage = 56;
      case 56: {
        if (tag == 450) {
         parse_askKickPlayerMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_askkickplayermessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(458)) goto parse_askKickDeniedMessage;
        break;
      }

      // optional .AskKickDeniedMessage askKickDeniedMessage = 57;
      case 57: {
        if (tag == 458) {
         parse_askKickDeniedMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_askkickdeniedmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(466)) goto parse_startKickPetitionMessage;
        break;
      }

      // optional .StartKickPetitionMessage startKickPetitionMessage = 58;
      case 58: {
        if (tag == 466) {
         parse_startKickPetitionMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_startkickpetitionmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(474)) goto parse_voteKickRequestMessage;
        break;
      }

      // optional .VoteKickRequestMessage voteKickRequestMessage = 59;
      case 59: {
        if (tag == 474) {
         parse_voteKickRequestMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_votekickrequestmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(482)) goto parse_voteKickReplyMessage;
        break;
      }

      // optional .VoteKickReplyMessage voteKickReplyMessage = 60;
      case 60: {
        if (tag == 482) {
         parse_voteKickReplyMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_votekickreplymessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(490)) goto parse_kickPetitionUpdateMessage;
        break;
      }

      // optional .KickPetitionUpdateMessage kickPetitionUpdateMessage = 61;
      case 61: {
        if (tag == 490) {
         parse_kickPetitionUpdateMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_kickpetitionupdatemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(498)) goto parse_endKickPetitionMessage;
        break;
      }

      // optional .EndKickPetitionMessage endKickPetitionMessage = 62;
      case 62: {
        if (tag == 498) {
         parse_endKickPetitionMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_endkickpetitionmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(506)) goto parse_statisticsMessage;
        break;
      }

      // optional .StatisticsMessage statisticsMessage = 63;
      case 63: {
        if (tag == 506) {
         parse_statisticsMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_statisticsmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(514)) goto parse_chatRequestMessage;
        break;
      }

      // optional .ChatRequestMessage chatRequestMessage = 64;
      case 64: {
        if (tag == 514) {
         parse_chatRequestMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_chatrequestmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(522)) goto parse_chatMessage;
        break;
      }

      // optional .ChatMessage chatMessage = 65;
      case 65: {
        if (tag == 522) {
         parse_chatMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_chatmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(530)) goto parse_chatRejectMessage;
        break;
      }

      // optional .ChatRejectMessage chatRejectMessage = 66;
      case 66: {
        if (tag == 530) {
         parse_chatRejectMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_chatrejectmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(538)) goto parse_dialogMessage;
        break;
      }

      // optional .DialogMessage dialogMessage = 67;
      case 67: {
        if (tag == 538) {
         parse_dialogMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_dialogmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(546)) goto parse_timeoutWarningMessage;
        break;
      }

      // optional .TimeoutWarningMessage timeoutWarningMessage = 68;
      case 68: {
        if (tag == 546) {
         parse_timeoutWarningMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_timeoutwarningmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(554)) goto parse_resetTimeoutMessage;
        break;
      }

      // optional .ResetTimeoutMessage resetTimeoutMessage = 69;
      case 69: {
        if (tag == 554) {
         parse_resetTimeoutMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_resettimeoutmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(562)) goto parse_reportAvatarMessage;
        break;
      }

      // optional .ReportAvatarMessage reportAvatarMessage = 70;
      case 70: {
        if (tag == 562) {
         parse_reportAvatarMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_reportavatarmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(570)) goto parse_reportAvatarAckMessage;
        break;
      }

      // optional .ReportAvatarAckMessage reportAvatarAckMessage = 71;
      case 71: {
        if (tag == 570) {
         parse_reportAvatarAckMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_reportavatarackmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(578)) goto parse_reportGameMessage;
        break;
      }

      // optional .ReportGameMessage reportGameMessage = 72;
      case 72: {
        if (tag == 578) {
         parse_reportGameMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_reportgamemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(586)) goto parse_reportGameAckMessage;
        break;
      }

      // optional .ReportGameAckMessage reportGameAckMessage = 73;
      case 73: {
        if (tag == 586) {
         parse_reportGameAckMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_reportgameackmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(594)) goto parse_errorMessage;
        break;
      }

      // optional .ErrorMessage errorMessage = 74;
      case 74: {
        if (tag == 594) {
         parse_errorMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_errormessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(602)) goto parse_adminRemoveGameMessage;
        break;
      }

      // optional .AdminRemoveGameMessage adminRemoveGameMessage = 75;
      case 75: {
        if (tag == 602) {
         parse_adminRemoveGameMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_adminremovegamemessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(610)) goto parse_adminRemoveGameAckMessage;
        break;
      }

      // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76;
      case 76: {
        if (tag == 610) {
         parse_adminRemoveGameAckMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_adminremovegameackmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(618)) goto parse_adminBanPlayerMessage;
        break;
      }

      // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77;
      case 77: {
        if (tag == 618) {
         parse_adminBanPlayerMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_adminbanplayermessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(626)) goto parse_adminBanPlayerAckMessage;
        break;
      }

      // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78;
      case 78: {
        if (tag == 626) {
         parse_adminBanPlayerAckMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_adminbanplayerackmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(634)) goto parse_gameListSpectatorJoinedMessage;
        break;
      }

      // optional .GameListSpectatorJoinedMessage gameListSpectatorJoinedMessage = 79;
      case 79: {
        if (tag == 634) {
         parse_gameListSpectatorJoinedMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamelistspectatorjoinedmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(642)) goto parse_gameListSpectatorLeftMessage;
        break;
      }

      // optional .GameListSpectatorLeftMessage gameListSpectatorLeftMessage = 80;
      case 80: {
        if (tag == 642) {
         parse_gameListSpectatorLeftMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamelistspectatorleftmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(650)) goto parse_gameSpectatorJoinedMessage;
        break;
      }

      // optional .GameSpectatorJoinedMessage gameSpectatorJoinedMessage = 81;
      case 81: {
        if (tag == 650) {
         parse_gameSpectatorJoinedMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamespectatorjoinedmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(658)) goto parse_gameSpectatorLeftMessage;
        break;
      }

      // optional .GameSpectatorLeftMessage gameSpectatorLeftMessage = 82;
      case 82: {
        if (tag == 658) {
         parse_gameSpectatorLeftMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gamespectatorleftmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PokerTHMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PokerTHMessage)
  return false;
#undef DO_
}

void PokerTHMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PokerTHMessage)
  // required .PokerTHMessage.PokerTHMessageType messageType = 1;
  if (has_messagetype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->messagetype(), output);
  }

  // optional .AnnounceMessage announceMessage = 2;
  if (has_announcemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->announcemessage(), output);
  }

  // optional .InitMessage initMessage = 3;
  if (has_initmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->initmessage(), output);
  }

  // optional .AuthServerChallengeMessage authServerChallengeMessage = 4;
  if (has_authserverchallengemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, this->authserverchallengemessage(), output);
  }

  // optional .AuthClientResponseMessage authClientResponseMessage = 5;
  if (has_authclientresponsemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, this->authclientresponsemessage(), output);
  }

  // optional .AuthServerVerificationMessage authServerVerificationMessage = 6;
  if (has_authserververificationmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      6, this->authserververificationmessage(), output);
  }

  // optional .InitAckMessage initAckMessage = 7;
  if (has_initackmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      7, this->initackmessage(), output);
  }

  // optional .AvatarRequestMessage avatarRequestMessage = 8;
  if (has_avatarrequestmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      8, this->avatarrequestmessage(), output);
  }

  // optional .AvatarHeaderMessage avatarHeaderMessage = 9;
  if (has_avatarheadermessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      9, this->avatarheadermessage(), output);
  }

  // optional .AvatarDataMessage avatarDataMessage = 10;
  if (has_avatardatamessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      10, this->avatardatamessage(), output);
  }

  // optional .AvatarEndMessage avatarEndMessage = 11;
  if (has_avatarendmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      11, this->avatarendmessage(), output);
  }

  // optional .UnknownAvatarMessage unknownAvatarMessage = 12;
  if (has_unknownavatarmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      12, this->unknownavatarmessage(), output);
  }

  // optional .PlayerListMessage playerListMessage = 13;
  if (has_playerlistmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      13, this->playerlistmessage(), output);
  }

  // optional .GameListNewMessage gameListNewMessage = 14;
  if (has_gamelistnewmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      14, this->gamelistnewmessage(), output);
  }

  // optional .GameListUpdateMessage gameListUpdateMessage = 15;
  if (has_gamelistupdatemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      15, this->gamelistupdatemessage(), output);
  }

  // optional .GameListPlayerJoinedMessage gameListPlayerJoinedMessage = 16;
  if (has_gamelistplayerjoinedmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      16, this->gamelistplayerjoinedmessage(), output);
  }

  // optional .GameListPlayerLeftMessage gameListPlayerLeftMessage = 17;
  if (has_gamelistplayerleftmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      17, this->gamelistplayerleftmessage(), output);
  }

  // optional .GameListAdminChangedMessage gameListAdminChangedMessage = 18;
  if (has_gamelistadminchangedmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      18, this->gamelistadminchangedmessage(), output);
  }

  // optional .PlayerInfoRequestMessage playerInfoRequestMessage = 19;
  if (has_playerinforequestmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      19, this->playerinforequestmessage(), output);
  }

  // optional .PlayerInfoReplyMessage playerInfoReplyMessage = 20;
  if (has_playerinforeplymessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      20, this->playerinforeplymessage(), output);
  }

  // optional .SubscriptionRequestMessage subscriptionRequestMessage = 21;
  if (has_subscriptionrequestmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      21, this->subscriptionrequestmessage(), output);
  }

  // optional .JoinExistingGameMessage joinExistingGameMessage = 22;
  if (has_joinexistinggamemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      22, this->joinexistinggamemessage(), output);
  }

  // optional .JoinNewGameMessage joinNewGameMessage = 23;
  if (has_joinnewgamemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      23, this->joinnewgamemessage(), output);
  }

  // optional .RejoinExistingGameMessage rejoinExistingGameMessage = 24;
  if (has_rejoinexistinggamemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      24, this->rejoinexistinggamemessage(), output);
  }

  // optional .JoinGameAckMessage joinGameAckMessage = 25;
  if (has_joingameackmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      25, this->joingameackmessage(), output);
  }

  // optional .JoinGameFailedMessage joinGameFailedMessage = 26;
  if (has_joingamefailedmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      26, this->joingamefailedmessage(), output);
  }

  // optional .GamePlayerJoinedMessage gamePlayerJoinedMessage = 27;
  if (has_gameplayerjoinedmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      27, this->gameplayerjoinedmessage(), output);
  }

  // optional .GamePlayerLeftMessage gamePlayerLeftMessage = 28;
  if (has_gameplayerleftmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      28, this->gameplayerleftmessage(), output);
  }

  // optional .GameAdminChangedMessage gameAdminChangedMessage = 29;
  if (has_gameadminchangedmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      29, this->gameadminchangedmessage(), output);
  }

  // optional .RemovedFromGameMessage removedFromGameMessage = 30;
  if (has_removedfromgamemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      30, this->removedfromgamemessage(), output);
  }

  // optional .KickPlayerRequestMessage kickPlayerRequestMessage = 31;
  if (has_kickplayerrequestmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      31, this->kickplayerrequestmessage(), output);
  }

  // optional .LeaveGameRequestMessage leaveGameRequestMessage = 32;
  if (has_leavegamerequestmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      32, this->leavegamerequestmessage(), output);
  }

  // optional .InvitePlayerToGameMessage invitePlayerToGameMessage = 33;
  if (has_inviteplayertogamemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      33, this->inviteplayertogamemessage(), output);
  }

  // optional .InviteNotifyMessage inviteNotifyMessage = 34;
  if (has_invitenotifymessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      34, this->invitenotifymessage(), output);
  }

  // optional .RejectGameInvitationMessage rejectGameInvitationMessage = 35;
  if (has_rejectgameinvitationmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      35, this->rejectgameinvitationmessage(), output);
  }

  // optional .RejectInvNotifyMessage rejectInvNotifyMessage = 36;
  if (has_rejectinvnotifymessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      36, this->rejectinvnotifymessage(), output);
  }

  // optional .StartEventMessage startEventMessage = 37;
  if (has_starteventmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      37, this->starteventmessage(), output);
  }

  // optional .StartEventAckMessage startEventAckMessage = 38;
  if (has_starteventackmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      38, this->starteventackmessage(), output);
  }

  // optional .GameStartInitialMessage gameStartInitialMessage = 39;
  if (has_gamestartinitialmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      39, this->gamestartinitialmessage(), output);
  }

  // optional .GameStartRejoinMessage gameStartRejoinMessage = 40;
  if (has_gamestartrejoinmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      40, this->gamestartrejoinmessage(), output);
  }

  // optional .HandStartMessage handStartMessage = 41;
  if (has_handstartmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      41, this->handstartmessage(), output);
  }

  // optional .PlayersTurnMessage playersTurnMessage = 42;
  if (has_playersturnmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      42, this->playersturnmessage(), output);
  }

  // optional .MyActionRequestMessage myActionRequestMessage = 43;
  if (has_myactionrequestmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      43, this->myactionrequestmessage(), output);
  }

  // optional .YourActionRejectedMessage yourActionRejectedMessage = 44;
  if (has_youractionrejectedmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      44, this->youractionrejectedmessage(), output);
  }

  // optional .PlayersActionDoneMessage playersActionDoneMessage = 45;
  if (has_playersactiondonemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      45, this->playersactiondonemessage(), output);
  }

  // optional .DealFlopCardsMessage dealFlopCardsMessage = 46;
  if (has_dealflopcardsmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      46, this->dealflopcardsmessage(), output);
  }

  // optional .DealTurnCardMessage dealTurnCardMessage = 47;
  if (has_dealturncardmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      47, this->dealturncardmessage(), output);
  }

  // optional .DealRiverCardMessage dealRiverCardMessage = 48;
  if (has_dealrivercardmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      48, this->dealrivercardmessage(), output);
  }

  // optional .AllInShowCardsMessage allInShowCardsMessage = 49;
  if (has_allinshowcardsmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      49, this->allinshowcardsmessage(), output);
  }

  // optional .EndOfHandShowCardsMessage endOfHandShowCardsMessage = 50;
  if (has_endofhandshowcardsmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      50, this->endofhandshowcardsmessage(), output);
  }

  // optional .EndOfHandHideCardsMessage endOfHandHideCardsMessage = 51;
  if (has_endofhandhidecardsmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      51, this->endofhandhidecardsmessage(), output);
  }

  // optional .ShowMyCardsRequestMessage showMyCardsRequestMessage = 52;
  if (has_showmycardsrequestmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      52, this->showmycardsrequestmessage(), output);
  }

  // optional .AfterHandShowCardsMessage afterHandShowCardsMessage = 53;
  if (has_afterhandshowcardsmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      53, this->afterhandshowcardsmessage(), output);
  }

  // optional .EndOfGameMessage endOfGameMessage = 54;
  if (has_endofgamemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      54, this->endofgamemessage(), output);
  }

  // optional .PlayerIdChangedMessage playerIdChangedMessage = 55;
  if (has_playeridchangedmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      55, this->playeridchangedmessage(), output);
  }

  // optional .AskKickPlayerMessage askKickPlayerMessage = 56;
  if (has_askkickplayermessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      56, this->askkickplayermessage(), output);
  }

  // optional .AskKickDeniedMessage askKickDeniedMessage = 57;
  if (has_askkickdeniedmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      57, this->askkickdeniedmessage(), output);
  }

  // optional .StartKickPetitionMessage startKickPetitionMessage = 58;
  if (has_startkickpetitionmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      58, this->startkickpetitionmessage(), output);
  }

  // optional .VoteKickRequestMessage voteKickRequestMessage = 59;
  if (has_votekickrequestmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      59, this->votekickrequestmessage(), output);
  }

  // optional .VoteKickReplyMessage voteKickReplyMessage = 60;
  if (has_votekickreplymessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      60, this->votekickreplymessage(), output);
  }

  // optional .KickPetitionUpdateMessage kickPetitionUpdateMessage = 61;
  if (has_kickpetitionupdatemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      61, this->kickpetitionupdatemessage(), output);
  }

  // optional .EndKickPetitionMessage endKickPetitionMessage = 62;
  if (has_endkickpetitionmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      62, this->endkickpetitionmessage(), output);
  }

  // optional .StatisticsMessage statisticsMessage = 63;
  if (has_statisticsmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      63, this->statisticsmessage(), output);
  }

  // optional .ChatRequestMessage chatRequestMessage = 64;
  if (has_chatrequestmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      64, this->chatrequestmessage(), output);
  }

  // optional .ChatMessage chatMessage = 65;
  if (has_chatmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      65, this->chatmessage(), output);
  }

  // optional .ChatRejectMessage chatRejectMessage = 66;
  if (has_chatrejectmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      66, this->chatrejectmessage(), output);
  }

  // optional .DialogMessage dialogMessage = 67;
  if (has_dialogmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      67, this->dialogmessage(), output);
  }

  // optional .TimeoutWarningMessage timeoutWarningMessage = 68;
  if (has_timeoutwarningmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      68, this->timeoutwarningmessage(), output);
  }

  // optional .ResetTimeoutMessage resetTimeoutMessage = 69;
  if (has_resettimeoutmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      69, this->resettimeoutmessage(), output);
  }

  // optional .ReportAvatarMessage reportAvatarMessage = 70;
  if (has_reportavatarmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      70, this->reportavatarmessage(), output);
  }

  // optional .ReportAvatarAckMessage reportAvatarAckMessage = 71;
  if (has_reportavatarackmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      71, this->reportavatarackmessage(), output);
  }

  // optional .ReportGameMessage reportGameMessage = 72;
  if (has_reportgamemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      72, this->reportgamemessage(), output);
  }

  // optional .ReportGameAckMessage reportGameAckMessage = 73;
  if (has_reportgameackmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      73, this->reportgameackmessage(), output);
  }

  // optional .ErrorMessage errorMessage = 74;
  if (has_errormessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      74, this->errormessage(), output);
  }

  // optional .AdminRemoveGameMessage adminRemoveGameMessage = 75;
  if (has_adminremovegamemessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      75, this->adminremovegamemessage(), output);
  }

  // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76;
  if (has_adminremovegameackmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      76, this->adminremovegameackmessage(), output);
  }

  // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77;
  if (has_adminbanplayermessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      77, this->adminbanplayermessage(), output);
  }

  // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78;
  if (has_adminbanplayerackmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      78, this->adminbanplayerackmessage(), output);
  }

  // optional .GameListSpectatorJoinedMessage gameListSpectatorJoinedMessage = 79;
  if (has_gamelistspectatorjoinedmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      79, this->gamelistspectatorjoinedmessage(), output);
  }

  // optional .GameListSpectatorLeftMessage gameListSpectatorLeftMessage = 80;
  if (has_gamelistspectatorleftmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      80, this->gamelistspectatorleftmessage(), output);
  }

  // optional .GameSpectatorJoinedMessage gameSpectatorJoinedMessage = 81;
  if (has_gamespectatorjoinedmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      81, this->gamespectatorjoinedmessage(), output);
  }

  // optional .GameSpectatorLeftMessage gameSpectatorLeftMessage = 82;
  if (has_gamespectatorleftmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      82, this->gamespectatorleftmessage(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PokerTHMessage)
}

int PokerTHMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .PokerTHMessage.PokerTHMessageType messageType = 1;
    if (has_messagetype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->messagetype());
    }

    // optional .AnnounceMessage announceMessage = 2;
    if (has_announcemessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->announcemessage());
    }

    // optional .InitMessage initMessage = 3;
    if (has_initmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->initmessage());
    }

    // optional .AuthServerChallengeMessage authServerChallengeMessage = 4;
    if (has_authserverchallengemessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->authserverchallengemessage());
    }

    // optional .AuthClientResponseMessage authClientResponseMessage = 5;
    if (has_authclientresponsemessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->authclientresponsemessage());
    }

    // optional .AuthServerVerificationMessage authServerVerificationMessage = 6;
    if (has_authserververificationmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->authserververificationmessage());
    }

    // optional .InitAckMessage initAckMessage = 7;
    if (has_initackmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->initackmessage());
    }

    // optional .AvatarRequestMessage avatarRequestMessage = 8;
    if (has_avatarrequestmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->avatarrequestmessage());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional .AvatarHeaderMessage avatarHeaderMessage = 9;
    if (has_avatarheadermessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->avatarheadermessage());
    }

    // optional .AvatarDataMessage avatarDataMessage = 10;
    if (has_avatardatamessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->avatardatamessage());
    }

    // optional .AvatarEndMessage avatarEndMessage = 11;
    if (has_avatarendmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->avatarendmessage());
    }

    // optional .UnknownAvatarMessage unknownAvatarMessage = 12;
    if (has_unknownavatarmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->unknownavatarmessage());
    }

    // optional .PlayerListMessage playerListMessage = 13;
    if (has_playerlistmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->playerlistmessage());
    }

    // optional .GameListNewMessage gameListNewMessage = 14;
    if (has_gamelistnewmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamelistnewmessage());
    }

    // optional .GameListUpdateMessage gameListUpdateMessage = 15;
    if (has_gamelistupdatemessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamelistupdatemessage());
    }

    // optional .GameListPlayerJoinedMessage gameListPlayerJoinedMessage = 16;
    if (has_gamelistplayerjoinedmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamelistplayerjoinedmessage());
    }

  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    // optional .GameListPlayerLeftMessage gameListPlayerLeftMessage = 17;
    if (has_gamelistplayerleftmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamelistplayerleftmessage());
    }

    // optional .GameListAdminChangedMessage gameListAdminChangedMessage = 18;
    if (has_gamelistadminchangedmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamelistadminchangedmessage());
    }

    // optional .PlayerInfoRequestMessage playerInfoRequestMessage = 19;
    if (has_playerinforequestmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->playerinforequestmessage());
    }

    // optional .PlayerInfoReplyMessage playerInfoReplyMessage = 20;
    if (has_playerinforeplymessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->playerinforeplymessage());
    }

    // optional .SubscriptionRequestMessage subscriptionRequestMessage = 21;
    if (has_subscriptionrequestmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->subscriptionrequestmessage());
    }

    // optional .JoinExistingGameMessage joinExistingGameMessage = 22;
    if (has_joinexistinggamemessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->joinexistinggamemessage());
    }

    // optional .JoinNewGameMessage joinNewGameMessage = 23;
    if (has_joinnewgamemessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->joinnewgamemessage());
    }

    // optional .RejoinExistingGameMessage rejoinExistingGameMessage = 24;
    if (has_rejoinexistinggamemessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->rejoinexistinggamemessage());
    }

  }
  if (_has_bits_[24 / 32] & (0xffu << (24 % 32))) {
    // optional .JoinGameAckMessage joinGameAckMessage = 25;
    if (has_joingameackmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->joingameackmessage());
    }

    // optional .JoinGameFailedMessage joinGameFailedMessage = 26;
    if (has_joingamefailedmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->joingamefailedmessage());
    }

    // optional .GamePlayerJoinedMessage gamePlayerJoinedMessage = 27;
    if (has_gameplayerjoinedmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gameplayerjoinedmessage());
    }

    // optional .GamePlayerLeftMessage gamePlayerLeftMessage = 28;
    if (has_gameplayerleftmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gameplayerleftmessage());
    }

    // optional .GameAdminChangedMessage gameAdminChangedMessage = 29;
    if (has_gameadminchangedmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gameadminchangedmessage());
    }

    // optional .RemovedFromGameMessage removedFromGameMessage = 30;
    if (has_removedfromgamemessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->removedfromgamemessage());
    }

    // optional .KickPlayerRequestMessage kickPlayerRequestMessage = 31;
    if (has_kickplayerrequestmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->kickplayerrequestmessage());
    }

    // optional .LeaveGameRequestMessage leaveGameRequestMessage = 32;
    if (has_leavegamerequestmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->leavegamerequestmessage());
    }

  }
  if (_has_bits_[32 / 32] & (0xffu << (32 % 32))) {
    // optional .InvitePlayerToGameMessage invitePlayerToGameMessage = 33;
    if (has_inviteplayertogamemessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->inviteplayertogamemessage());
    }

    // optional .InviteNotifyMessage inviteNotifyMessage = 34;
    if (has_invitenotifymessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->invitenotifymessage());
    }

    // optional .RejectGameInvitationMessage rejectGameInvitationMessage = 35;
    if (has_rejectgameinvitationmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->rejectgameinvitationmessage());
    }

    // optional .RejectInvNotifyMessage rejectInvNotifyMessage = 36;
    if (has_rejectinvnotifymessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->rejectinvnotifymessage());
    }

    // optional .StartEventMessage startEventMessage = 37;
    if (has_starteventmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->starteventmessage());
    }

    // optional .StartEventAckMessage startEventAckMessage = 38;
    if (has_starteventackmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->starteventackmessage());
    }

    // optional .GameStartInitialMessage gameStartInitialMessage = 39;
    if (has_gamestartinitialmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamestartinitialmessage());
    }

    // optional .GameStartRejoinMessage gameStartRejoinMessage = 40;
    if (has_gamestartrejoinmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamestartrejoinmessage());
    }

  }
  if (_has_bits_[40 / 32] & (0xffu << (40 % 32))) {
    // optional .HandStartMessage handStartMessage = 41;
    if (has_handstartmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->handstartmessage());
    }

    // optional .PlayersTurnMessage playersTurnMessage = 42;
    if (has_playersturnmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->playersturnmessage());
    }

    // optional .MyActionRequestMessage myActionRequestMessage = 43;
    if (has_myactionrequestmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->myactionrequestmessage());
    }

    // optional .YourActionRejectedMessage yourActionRejectedMessage = 44;
    if (has_youractionrejectedmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->youractionrejectedmessage());
    }

    // optional .PlayersActionDoneMessage playersActionDoneMessage = 45;
    if (has_playersactiondonemessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->playersactiondonemessage());
    }

    // optional .DealFlopCardsMessage dealFlopCardsMessage = 46;
    if (has_dealflopcardsmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->dealflopcardsmessage());
    }

    // optional .DealTurnCardMessage dealTurnCardMessage = 47;
    if (has_dealturncardmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->dealturncardmessage());
    }

    // optional .DealRiverCardMessage dealRiverCardMessage = 48;
    if (has_dealrivercardmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->dealrivercardmessage());
    }

  }
  if (_has_bits_[48 / 32] & (0xffu << (48 % 32))) {
    // optional .AllInShowCardsMessage allInShowCardsMessage = 49;
    if (has_allinshowcardsmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->allinshowcardsmessage());
    }

    // optional .EndOfHandShowCardsMessage endOfHandShowCardsMessage = 50;
    if (has_endofhandshowcardsmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->endofhandshowcardsmessage());
    }

    // optional .EndOfHandHideCardsMessage endOfHandHideCardsMessage = 51;
    if (has_endofhandhidecardsmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->endofhandhidecardsmessage());
    }

    // optional .ShowMyCardsRequestMessage showMyCardsRequestMessage = 52;
    if (has_showmycardsrequestmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->showmycardsrequestmessage());
    }

    // optional .AfterHandShowCardsMessage afterHandShowCardsMessage = 53;
    if (has_afterhandshowcardsmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->afterhandshowcardsmessage());
    }

    // optional .EndOfGameMessage endOfGameMessage = 54;
    if (has_endofgamemessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->endofgamemessage());
    }

    // optional .PlayerIdChangedMessage playerIdChangedMessage = 55;
    if (has_playeridchangedmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->playeridchangedmessage());
    }

    // optional .AskKickPlayerMessage askKickPlayerMessage = 56;
    if (has_askkickplayermessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->askkickplayermessage());
    }

  }
  if (_has_bits_[56 / 32] & (0xffu << (56 % 32))) {
    // optional .AskKickDeniedMessage askKickDeniedMessage = 57;
    if (has_askkickdeniedmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->askkickdeniedmessage());
    }

    // optional .StartKickPetitionMessage startKickPetitionMessage = 58;
    if (has_startkickpetitionmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->startkickpetitionmessage());
    }

    // optional .VoteKickRequestMessage voteKickRequestMessage = 59;
    if (has_votekickrequestmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->votekickrequestmessage());
    }

    // optional .VoteKickReplyMessage voteKickReplyMessage = 60;
    if (has_votekickreplymessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->votekickreplymessage());
    }

    // optional .KickPetitionUpdateMessage kickPetitionUpdateMessage = 61;
    if (has_kickpetitionupdatemessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->kickpetitionupdatemessage());
    }

    // optional .EndKickPetitionMessage endKickPetitionMessage = 62;
    if (has_endkickpetitionmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->endkickpetitionmessage());
    }

    // optional .StatisticsMessage statisticsMessage = 63;
    if (has_statisticsmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->statisticsmessage());
    }

    // optional .ChatRequestMessage chatRequestMessage = 64;
    if (has_chatrequestmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->chatrequestmessage());
    }

  }
  if (_has_bits_[64 / 32] & (0xffu << (64 % 32))) {
    // optional .ChatMessage chatMessage = 65;
    if (has_chatmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->chatmessage());
    }

    // optional .ChatRejectMessage chatRejectMessage = 66;
    if (has_chatrejectmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->chatrejectmessage());
    }

    // optional .DialogMessage dialogMessage = 67;
    if (has_dialogmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->dialogmessage());
    }

    // optional .TimeoutWarningMessage timeoutWarningMessage = 68;
    if (has_timeoutwarningmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->timeoutwarningmessage());
    }

    // optional .ResetTimeoutMessage resetTimeoutMessage = 69;
    if (has_resettimeoutmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->resettimeoutmessage());
    }

    // optional .ReportAvatarMessage reportAvatarMessage = 70;
    if (has_reportavatarmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->reportavatarmessage());
    }

    // optional .ReportAvatarAckMessage reportAvatarAckMessage = 71;
    if (has_reportavatarackmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->reportavatarackmessage());
    }

    // optional .ReportGameMessage reportGameMessage = 72;
    if (has_reportgamemessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->reportgamemessage());
    }

  }
  if (_has_bits_[72 / 32] & (0xffu << (72 % 32))) {
    // optional .ReportGameAckMessage reportGameAckMessage = 73;
    if (has_reportgameackmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->reportgameackmessage());
    }

    // optional .ErrorMessage errorMessage = 74;
    if (has_errormessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->errormessage());
    }

    // optional .AdminRemoveGameMessage adminRemoveGameMessage = 75;
    if (has_adminremovegamemessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->adminremovegamemessage());
    }

    // optional .AdminRemoveGameAckMessage adminRemoveGameAckMessage = 76;
    if (has_adminremovegameackmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->adminremovegameackmessage());
    }

    // optional .AdminBanPlayerMessage adminBanPlayerMessage = 77;
    if (has_adminbanplayermessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->adminbanplayermessage());
    }

    // optional .AdminBanPlayerAckMessage adminBanPlayerAckMessage = 78;
    if (has_adminbanplayerackmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->adminbanplayerackmessage());
    }

    // optional .GameListSpectatorJoinedMessage gameListSpectatorJoinedMessage = 79;
    if (has_gamelistspectatorjoinedmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamelistspectatorjoinedmessage());
    }

    // optional .GameListSpectatorLeftMessage gameListSpectatorLeftMessage = 80;
    if (has_gamelistspectatorleftmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamelistspectatorleftmessage());
    }

  }
  if (_has_bits_[80 / 32] & (0xffu << (80 % 32))) {
    // optional .GameSpectatorJoinedMessage gameSpectatorJoinedMessage = 81;
    if (has_gamespectatorjoinedmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamespectatorjoinedmessage());
    }

    // optional .GameSpectatorLeftMessage gameSpectatorLeftMessage = 82;
    if (has_gamespectatorleftmessage()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gamespectatorleftmessage());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PokerTHMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PokerTHMessage*>(&from));
}

void PokerTHMessage::MergeFrom(const PokerTHMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_messagetype()) {
      set_messagetype(from.messagetype());
    }
    if (from.has_announcemessage()) {
      mutable_announcemessage()->::AnnounceMessage::MergeFrom(from.announcemessage());
    }
    if (from.has_initmessage()) {
      mutable_initmessage()->::InitMessage::MergeFrom(from.initmessage());
    }
    if (from.has_authserverchallengemessage()) {
      mutable_authserverchallengemessage()->::AuthServerChallengeMessage::MergeFrom(from.authserverchallengemessage());
    }
    if (from.has_authclientresponsemessage()) {
      mutable_authclientresponsemessage()->::AuthClientResponseMessage::MergeFrom(from.authclientresponsemessage());
    }
    if (from.has_authserververificationmessage()) {
      mutable_authserververificationmessage()->::AuthServerVerificationMessage::MergeFrom(from.authserververificationmessage());
    }
    if (from.has_initackmessage()) {
      mutable_initackmessage()->::InitAckMessage::MergeFrom(from.initackmessage());
    }
    if (from.has_avatarrequestmessage()) {
      mutable_avatarrequestmessage()->::AvatarRequestMessage::MergeFrom(from.avatarrequestmessage());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_avatarheadermessage()) {
      mutable_avatarheadermessage()->::AvatarHeaderMessage::MergeFrom(from.avatarheadermessage());
    }
    if (from.has_avatardatamessage()) {
      mutable_avatardatamessage()->::AvatarDataMessage::MergeFrom(from.avatardatamessage());
    }
    if (from.has_avatarendmessage()) {
      mutable_avatarendmessage()->::AvatarEndMessage::MergeFrom(from.avatarendmessage());
    }
    if (from.has_unknownavatarmessage()) {
      mutable_unknownavatarmessage()->::UnknownAvatarMessage::MergeFrom(from.unknownavatarmessage());
    }
    if (from.has_playerlistmessage()) {
      mutable_playerlistmessage()->::PlayerListMessage::MergeFrom(from.playerlistmessage());
    }
    if (from.has_gamelistnewmessage()) {
      mutable_gamelistnewmessage()->::GameListNewMessage::MergeFrom(from.gamelistnewmessage());
    }
    if (from.has_gamelistupdatemessage()) {
      mutable_gamelistupdatemessage()->::GameListUpdateMessage::MergeFrom(from.gamelistupdatemessage());
    }
    if (from.has_gamelistplayerjoinedmessage()) {
      mutable_gamelistplayerjoinedmessage()->::GameListPlayerJoinedMessage::MergeFrom(from.gamelistplayerjoinedmessage());
    }
  }
  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (from.has_gamelistplayerleftmessage()) {
      mutable_gamelistplayerleftmessage()->::GameListPlayerLeftMessage::MergeFrom(from.gamelistplayerleftmessage());
    }
    if (from.has_gamelistadminchangedmessage()) {
      mutable_gamelistadminchangedmessage()->::GameListAdminChangedMessage::MergeFrom(from.gamelistadminchangedmessage());
    }
    if (from.has_playerinforequestmessage()) {
      mutable_playerinforequestmessage()->::PlayerInfoRequestMessage::MergeFrom(from.playerinforequestmessage());
    }
    if (from.has_playerinforeplymessage()) {
      mutable_playerinforeplymessage()->::PlayerInfoReplyMessage::MergeFrom(from.playerinforeplymessage());
    }
    if (from.has_subscriptionrequestmessage()) {
      mutable_subscriptionrequestmessage()->::SubscriptionRequestMessage::MergeFrom(from.subscriptionrequestmessage());
    }
    if (from.has_joinexistinggamemessage()) {
      mutable_joinexistinggamemessage()->::JoinExistingGameMessage::MergeFrom(from.joinexistinggamemessage());
    }
    if (from.has_joinnewgamemessage()) {
      mutable_joinnewgamemessage()->::JoinNewGameMessage::MergeFrom(from.joinnewgamemessage());
    }
    if (from.has_rejoinexistinggamemessage()) {
      mutable_rejoinexistinggamemessage()->::RejoinExistingGameMessage::MergeFrom(from.rejoinexistinggamemessage());
    }
  }
  if (from._has_bits_[24 / 32] & (0xffu << (24 % 32))) {
    if (from.has_joingameackmessage()) {
      mutable_joingameackmessage()->::JoinGameAckMessage::MergeFrom(from.joingameackmessage());
    }
    if (from.has_joingamefailedmessage()) {
      mutable_joingamefailedmessage()->::JoinGameFailedMessage::MergeFrom(from.joingamefailedmessage());
    }
    if (from.has_gameplayerjoinedmessage()) {
      mutable_gameplayerjoinedmessage()->::GamePlayerJoinedMessage::MergeFrom(from.gameplayerjoinedmessage());
    }
    if (from.has_gameplayerleftmessage()) {
      mutable_gameplayerleftmessage()->::GamePlayerLeftMessage::MergeFrom(from.gameplayerleftmessage());
    }
    if (from.has_gameadminchangedmessage()) {
      mutable_gameadminchangedmessage()->::GameAdminChangedMessage::MergeFrom(from.gameadminchangedmessage());
    }
    if (from.has_removedfromgamemessage()) {
      mutable_removedfromgamemessage()->::RemovedFromGameMessage::MergeFrom(from.removedfromgamemessage());
    }
    if (from.has_kickplayerrequestmessage()) {
      mutable_kickplayerrequestmessage()->::KickPlayerRequestMessage::MergeFrom(from.kickplayerrequestmessage());
    }
    if (from.has_leavegamerequestmessage()) {
      mutable_leavegamerequestmessage()->::LeaveGameRequestMessage::MergeFrom(from.leavegamerequestmessage());
    }
  }
  if (from._has_bits_[32 / 32] & (0xffu << (32 % 32))) {
    if (from.has_inviteplayertogamemessage()) {
      mutable_inviteplayertogamemessage()->::InvitePlayerToGameMessage::MergeFrom(from.inviteplayertogamemessage());
    }
    if (from.has_invitenotifymessage()) {
      mutable_invitenotifymessage()->::InviteNotifyMessage::MergeFrom(from.invitenotifymessage());
    }
    if (from.has_rejectgameinvitationmessage()) {
      mutable_rejectgameinvitationmessage()->::RejectGameInvitationMessage::MergeFrom(from.rejectgameinvitationmessage());
    }
    if (from.has_rejectinvnotifymessage()) {
      mutable_rejectinvnotifymessage()->::RejectInvNotifyMessage::MergeFrom(from.rejectinvnotifymessage());
    }
    if (from.has_starteventmessage()) {
      mutable_starteventmessage()->::StartEventMessage::MergeFrom(from.starteventmessage());
    }
    if (from.has_starteventackmessage()) {
      mutable_starteventackmessage()->::StartEventAckMessage::MergeFrom(from.starteventackmessage());
    }
    if (from.has_gamestartinitialmessage()) {
      mutable_gamestartinitialmessage()->::GameStartInitialMessage::MergeFrom(from.gamestartinitialmessage());
    }
    if (from.has_gamestartrejoinmessage()) {
      mutable_gamestartrejoinmessage()->::GameStartRejoinMessage::MergeFrom(from.gamestartrejoinmessage());
    }
  }
  if (from._has_bits_[40 / 32] & (0xffu << (40 % 32))) {
    if (from.has_handstartmessage()) {
      mutable_handstartmessage()->::HandStartMessage::MergeFrom(from.handstartmessage());
    }
    if (from.has_playersturnmessage()) {
      mutable_playersturnmessage()->::PlayersTurnMessage::MergeFrom(from.playersturnmessage());
    }
    if (from.has_myactionrequestmessage()) {
      mutable_myactionrequestmessage()->::MyActionRequestMessage::MergeFrom(from.myactionrequestmessage());
    }
    if (from.has_youractionrejectedmessage()) {
      mutable_youractionrejectedmessage()->::YourActionRejectedMessage::MergeFrom(from.youractionrejectedmessage());
    }
    if (from.has_playersactiondonemessage()) {
      mutable_playersactiondonemessage()->::PlayersActionDoneMessage::MergeFrom(from.playersactiondonemessage());
    }
    if (from.has_dealflopcardsmessage()) {
      mutable_dealflopcardsmessage()->::DealFlopCardsMessage::MergeFrom(from.dealflopcardsmessage());
    }
    if (from.has_dealturncardmessage()) {
      mutable_dealturncardmessage()->::DealTurnCardMessage::MergeFrom(from.dealturncardmessage());
    }
    if (from.has_dealrivercardmessage()) {
      mutable_dealrivercardmessage()->::DealRiverCardMessage::MergeFrom(from.dealrivercardmessage());
    }
  }
  if (from._has_bits_[48 / 32] & (0xffu << (48 % 32))) {
    if (from.has_allinshowcardsmessage()) {
      mutable_allinshowcardsmessage()->::AllInShowCardsMessage::MergeFrom(from.allinshowcardsmessage());
    }
    if (from.has_endofhandshowcardsmessage()) {
      mutable_endofhandshowcardsmessage()->::EndOfHandShowCardsMessage::MergeFrom(from.endofhandshowcardsmessage());
    }
    if (from.has_endofhandhidecardsmessage()) {
      mutable_endofhandhidecardsmessage()->::EndOfHandHideCardsMessage::MergeFrom(from.endofhandhidecardsmessage());
    }
    if (from.has_showmycardsrequestmessage()) {
      mutable_showmycardsrequestmessage()->::ShowMyCardsRequestMessage::MergeFrom(from.showmycardsrequestmessage());
    }
    if (from.has_afterhandshowcardsmessage()) {
      mutable_afterhandshowcardsmessage()->::AfterHandShowCardsMessage::MergeFrom(from.afterhandshowcardsmessage());
    }
    if (from.has_endofgamemessage()) {
      mutable_endofgamemessage()->::EndOfGameMessage::MergeFrom(from.endofgamemessage());
    }
    if (from.has_playeridchangedmessage()) {
      mutable_playeridchangedmessage()->::PlayerIdChangedMessage::MergeFrom(from.playeridchangedmessage());
    }
    if (from.has_askkickplayermessage()) {
      mutable_askkickplayermessage()->::AskKickPlayerMessage::MergeFrom(from.askkickplayermessage());
    }
  }
  if (from._has_bits_[56 / 32] & (0xffu << (56 % 32))) {
    if (from.has_askkickdeniedmessage()) {
      mutable_askkickdeniedmessage()->::AskKickDeniedMessage::MergeFrom(from.askkickdeniedmessage());
    }
    if (from.has_startkickpetitionmessage()) {
      mutable_startkickpetitionmessage()->::StartKickPetitionMessage::MergeFrom(from.startkickpetitionmessage());
    }
    if (from.has_votekickrequestmessage()) {
      mutable_votekickrequestmessage()->::VoteKickRequestMessage::MergeFrom(from.votekickrequestmessage());
    }
    if (from.has_votekickreplymessage()) {
      mutable_votekickreplymessage()->::VoteKickReplyMessage::MergeFrom(from.votekickreplymessage());
    }
    if (from.has_kickpetitionupdatemessage()) {
      mutable_kickpetitionupdatemessage()->::KickPetitionUpdateMessage::MergeFrom(from.kickpetitionupdatemessage());
    }
    if (from.has_endkickpetitionmessage()) {
      mutable_endkickpetitionmessage()->::EndKickPetitionMessage::MergeFrom(from.endkickpetitionmessage());
    }
    if (from.has_statisticsmessage()) {
      mutable_statisticsmessage()->::StatisticsMessage::MergeFrom(from.statisticsmessage());
    }
    if (from.has_chatrequestmessage()) {
      mutable_chatrequestmessage()->::ChatRequestMessage::MergeFrom(from.chatrequestmessage());
    }
  }
  if (from._has_bits_[64 / 32] & (0xffu << (64 % 32))) {
    if (from.has_chatmessage()) {
      mutable_chatmessage()->::ChatMessage::MergeFrom(from.chatmessage());
    }
    if (from.has_chatrejectmessage()) {
      mutable_chatrejectmessage()->::ChatRejectMessage::MergeFrom(from.chatrejectmessage());
    }
    if (from.has_dialogmessage()) {
      mutable_dialogmessage()->::DialogMessage::MergeFrom(from.dialogmessage());
    }
    if (from.has_timeoutwarningmessage()) {
      mutable_timeoutwarningmessage()->::TimeoutWarningMessage::MergeFrom(from.timeoutwarningmessage());
    }
    if (from.has_resettimeoutmessage()) {
      mutable_resettimeoutmessage()->::ResetTimeoutMessage::MergeFrom(from.resettimeoutmessage());
    }
    if (from.has_reportavatarmessage()) {
      mutable_reportavatarmessage()->::ReportAvatarMessage::MergeFrom(from.reportavatarmessage());
    }
    if (from.has_reportavatarackmessage()) {
      mutable_reportavatarackmessage()->::ReportAvatarAckMessage::MergeFrom(from.reportavatarackmessage());
    }
    if (from.has_reportgamemessage()) {
      mutable_reportgamemessage()->::ReportGameMessage::MergeFrom(from.reportgamemessage());
    }
  }
  if (from._has_bits_[72 / 32] & (0xffu << (72 % 32))) {
    if (from.has_reportgameackmessage()) {
      mutable_reportgameackmessage()->::ReportGameAckMessage::MergeFrom(from.reportgameackmessage());
    }
    if (from.has_errormessage()) {
      mutable_errormessage()->::ErrorMessage::MergeFrom(from.errormessage());
    }
    if (from.has_adminremovegamemessage()) {
      mutable_adminremovegamemessage()->::AdminRemoveGameMessage::MergeFrom(from.adminremovegamemessage());
    }
    if (from.has_adminremovegameackmessage()) {
      mutable_adminremovegameackmessage()->::AdminRemoveGameAckMessage::MergeFrom(from.adminremovegameackmessage());
    }
    if (from.has_adminbanplayermessage()) {
      mutable_adminbanplayermessage()->::AdminBanPlayerMessage::MergeFrom(from.adminbanplayermessage());
    }
    if (from.has_adminbanplayerackmessage()) {
      mutable_adminbanplayerackmessage()->::AdminBanPlayerAckMessage::MergeFrom(from.adminbanplayerackmessage());
    }
    if (from.has_gamelistspectatorjoinedmessage()) {
      mutable_gamelistspectatorjoinedmessage()->::GameListSpectatorJoinedMessage::MergeFrom(from.gamelistspectatorjoinedmessage());
    }
    if (from.has_gamelistspectatorleftmessage()) {
      mutable_gamelistspectatorleftmessage()->::GameListSpectatorLeftMessage::MergeFrom(from.gamelistspectatorleftmessage());
    }
  }
  if (from._has_bits_[80 / 32] & (0xffu << (80 % 32))) {
    if (from.has_gamespectatorjoinedmessage()) {
      mutable_gamespectatorjoinedmessage()->::GameSpectatorJoinedMessage::MergeFrom(from.gamespectatorjoinedmessage());
    }
    if (from.has_gamespectatorleftmessage()) {
      mutable_gamespectatorleftmessage()->::GameSpectatorLeftMessage::MergeFrom(from.gamespectatorleftmessage());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PokerTHMessage::CopyFrom(const PokerTHMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PokerTHMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_announcemessage()) {
    if (!this->announcemessage().IsInitialized()) return false;
  }
  if (has_initmessage()) {
    if (!this->initmessage().IsInitialized()) return false;
  }
  if (has_authserverchallengemessage()) {
    if (!this->authserverchallengemessage().IsInitialized()) return false;
  }
  if (has_authclientresponsemessage()) {
    if (!this->authclientresponsemessage().IsInitialized()) return false;
  }
  if (has_authserververificationmessage()) {
    if (!this->authserververificationmessage().IsInitialized()) return false;
  }
  if (has_initackmessage()) {
    if (!this->initackmessage().IsInitialized()) return false;
  }
  if (has_avatarrequestmessage()) {
    if (!this->avatarrequestmessage().IsInitialized()) return false;
  }
  if (has_avatarheadermessage()) {
    if (!this->avatarheadermessage().IsInitialized()) return false;
  }
  if (has_avatardatamessage()) {
    if (!this->avatardatamessage().IsInitialized()) return false;
  }
  if (has_avatarendmessage()) {
    if (!this->avatarendmessage().IsInitialized()) return false;
  }
  if (has_unknownavatarmessage()) {
    if (!this->unknownavatarmessage().IsInitialized()) return false;
  }
  if (has_playerlistmessage()) {
    if (!this->playerlistmessage().IsInitialized()) return false;
  }
  if (has_gamelistnewmessage()) {
    if (!this->gamelistnewmessage().IsInitialized()) return false;
  }
  if (has_gamelistupdatemessage()) {
    if (!this->gamelistupdatemessage().IsInitialized()) return false;
  }
  if (has_gamelistplayerjoinedmessage()) {
    if (!this->gamelistplayerjoinedmessage().IsInitialized()) return false;
  }
  if (has_gamelistplayerleftmessage()) {
    if (!this->gamelistplayerleftmessage().IsInitialized()) return false;
  }
  if (has_gamelistadminchangedmessage()) {
    if (!this->gamelistadminchangedmessage().IsInitialized()) return false;
  }
  if (has_playerinforeplymessage()) {
    if (!this->playerinforeplymessage().IsInitialized()) return false;
  }
  if (has_subscriptionrequestmessage()) {
    if (!this->subscriptionrequestmessage().IsInitialized()) return false;
  }
  if (has_joinexistinggamemessage()) {
    if (!this->joinexistinggamemessage().IsInitialized()) return false;
  }
  if (has_joinnewgamemessage()) {
    if (!this->joinnewgamemessage().IsInitialized()) return false;
  }
  if (has_rejoinexistinggamemessage()) {
    if (!this->rejoinexistinggamemessage().IsInitialized()) return false;
  }
  if (has_joingameackmessage()) {
    if (!this->joingameackmessage().IsInitialized()) return false;
  }
  if (has_joingamefailedmessage()) {
    if (!this->joingamefailedmessage().IsInitialized()) return false;
  }
  if (has_gameplayerjoinedmessage()) {
    if (!this->gameplayerjoinedmessage().IsInitialized()) return false;
  }
  if (has_gameplayerleftmessage()) {
    if (!this->gameplayerleftmessage().IsInitialized()) return false;
  }
  if (has_gameadminchangedmessage()) {
    if (!this->gameadminchangedmessage().IsInitialized()) return false;
  }
  if (has_removedfromgamemessage()) {
    if (!this->removedfromgamemessage().IsInitialized()) return false;
  }
  if (has_kickplayerrequestmessage()) {
    if (!this->kickplayerrequestmessage().IsInitialized()) return false;
  }
  if (has_leavegamerequestmessage()) {
    if (!this->leavegamerequestmessage().IsInitialized()) return false;
  }
  if (has_inviteplayertogamemessage()) {
    if (!this->inviteplayertogamemessage().IsInitialized()) return false;
  }
  if (has_invitenotifymessage()) {
    if (!this->invitenotifymessage().IsInitialized()) return false;
  }
  if (has_rejectgameinvitationmessage()) {
    if (!this->rejectgameinvitationmessage().IsInitialized()) return false;
  }
  if (has_rejectinvnotifymessage()) {
    if (!this->rejectinvnotifymessage().IsInitialized()) return false;
  }
  if (has_starteventmessage()) {
    if (!this->starteventmessage().IsInitialized()) return false;
  }
  if (has_starteventackmessage()) {
    if (!this->starteventackmessage().IsInitialized()) return false;
  }
  if (has_gamestartinitialmessage()) {
    if (!this->gamestartinitialmessage().IsInitialized()) return false;
  }
  if (has_gamestartrejoinmessage()) {
    if (!this->gamestartrejoinmessage().IsInitialized()) return false;
  }
  if (has_handstartmessage()) {
    if (!this->handstartmessage().IsInitialized()) return false;
  }
  if (has_playersturnmessage()) {
    if (!this->playersturnmessage().IsInitialized()) return false;
  }
  if (has_myactionrequestmessage()) {
    if (!this->myactionrequestmessage().IsInitialized()) return false;
  }
  if (has_youractionrejectedmessage()) {
    if (!this->youractionrejectedmessage().IsInitialized()) return false;
  }
  if (has_playersactiondonemessage()) {
    if (!this->playersactiondonemessage().IsInitialized()) return false;
  }
  if (has_dealflopcardsmessage()) {
    if (!this->dealflopcardsmessage().IsInitialized()) return false;
  }
  if (has_dealturncardmessage()) {
    if (!this->dealturncardmessage().IsInitialized()) return false;
  }
  if (has_dealrivercardmessage()) {
    if (!this->dealrivercardmessage().IsInitialized()) return false;
  }
  if (has_allinshowcardsmessage()) {
    if (!this->allinshowcardsmessage().IsInitialized()) return false;
  }
  if (has_endofhandshowcardsmessage()) {
    if (!this->endofhandshowcardsmessage().IsInitialized()) return false;
  }
  if (has_endofhandhidecardsmessage()) {
    if (!this->endofhandhidecardsmessage().IsInitialized()) return false;
  }
  if (has_afterhandshowcardsmessage()) {
    if (!this->afterhandshowcardsmessage().IsInitialized()) return false;
  }
  if (has_endofgamemessage()) {
    if (!this->endofgamemessage().IsInitialized()) return false;
  }
  if (has_playeridchangedmessage()) {
    if (!this->playeridchangedmessage().IsInitialized()) return false;
  }
  if (has_askkickplayermessage()) {
    if (!this->askkickplayermessage().IsInitialized()) return false;
  }
  if (has_askkickdeniedmessage()) {
    if (!this->askkickdeniedmessage().IsInitialized()) return false;
  }
  if (has_startkickpetitionmessage()) {
    if (!this->startkickpetitionmessage().IsInitialized()) return false;
  }
  if (has_votekickrequestmessage()) {
    if (!this->votekickrequestmessage().IsInitialized()) return false;
  }
  if (has_votekickreplymessage()) {
    if (!this->votekickreplymessage().IsInitialized()) return false;
  }
  if (has_kickpetitionupdatemessage()) {
    if (!this->kickpetitionupdatemessage().IsInitialized()) return false;
  }
  if (has_endkickpetitionmessage()) {
    if (!this->endkickpetitionmessage().IsInitialized()) return false;
  }
  if (has_statisticsmessage()) {
    if (!this->statisticsmessage().IsInitialized()) return false;
  }
  if (has_chatrequestmessage()) {
    if (!this->chatrequestmessage().IsInitialized()) return false;
  }
  if (has_chatmessage()) {
    if (!this->chatmessage().IsInitialized()) return false;
  }
  if (has_chatrejectmessage()) {
    if (!this->chatrejectmessage().IsInitialized()) return false;
  }
  if (has_dialogmessage()) {
    if (!this->dialogmessage().IsInitialized()) return false;
  }
  if (has_timeoutwarningmessage()) {
    if (!this->timeoutwarningmessage().IsInitialized()) return false;
  }
  if (has_reportavatarmessage()) {
    if (!this->reportavatarmessage().IsInitialized()) return false;
  }
  if (has_reportavatarackmessage()) {
    if (!this->reportavatarackmessage().IsInitialized()) return false;
  }
  if (has_reportgamemessage()) {
    if (!this->reportgamemessage().IsInitialized()) return false;
  }
  if (has_reportgameackmessage()) {
    if (!this->reportgameackmessage().IsInitialized()) return false;
  }
  if (has_errormessage()) {
    if (!this->errormessage().IsInitialized()) return false;
  }
  if (has_adminremovegamemessage()) {
    if (!this->adminremovegamemessage().IsInitialized()) return false;
  }
  if (has_adminremovegameackmessage()) {
    if (!this->adminremovegameackmessage().IsInitialized()) return false;
  }
  if (has_adminbanplayermessage()) {
    if (!this->adminbanplayermessage().IsInitialized()) return false;
  }
  if (has_adminbanplayerackmessage()) {
    if (!this->adminbanplayerackmessage().IsInitialized()) return false;
  }
  if (has_gamelistspectatorjoinedmessage()) {
    if (!this->gamelistspectatorjoinedmessage().IsInitialized()) return false;
  }
  if (has_gamelistspectatorleftmessage()) {
    if (!this->gamelistspectatorleftmessage().IsInitialized()) return false;
  }
  if (has_gamespectatorjoinedmessage()) {
    if (!this->gamespectatorjoinedmessage().IsInitialized()) return false;
  }
  if (has_gamespectatorleftmessage()) {
    if (!this->gamespectatorleftmessage().IsInitialized()) return false;
  }
  return true;
}

void PokerTHMessage::Swap(PokerTHMessage* other) {
  if (other != this) {
    std::swap(messagetype_, other->messagetype_);
    std::swap(announcemessage_, other->announcemessage_);
    std::swap(initmessage_, other->initmessage_);
    std::swap(authserverchallengemessage_, other->authserverchallengemessage_);
    std::swap(authclientresponsemessage_, other->authclientresponsemessage_);
    std::swap(authserververificationmessage_, other->authserververificationmessage_);
    std::swap(initackmessage_, other->initackmessage_);
    std::swap(avatarrequestmessage_, other->avatarrequestmessage_);
    std::swap(avatarheadermessage_, other->avatarheadermessage_);
    std::swap(avatardatamessage_, other->avatardatamessage_);
    std::swap(avatarendmessage_, other->avatarendmessage_);
    std::swap(unknownavatarmessage_, other->unknownavatarmessage_);
    std::swap(playerlistmessage_, other->playerlistmessage_);
    std::swap(gamelistnewmessage_, other->gamelistnewmessage_);
    std::swap(gamelistupdatemessage_, other->gamelistupdatemessage_);
    std::swap(gamelistplayerjoinedmessage_, other->gamelistplayerjoinedmessage_);
    std::swap(gamelistplayerleftmessage_, other->gamelistplayerleftmessage_);
    std::swap(gamelistadminchangedmessage_, other->gamelistadminchangedmessage_);
    std::swap(playerinforequestmessage_, other->playerinforequestmessage_);
    std::swap(playerinforeplymessage_, other->playerinforeplymessage_);
    std::swap(subscriptionrequestmessage_, other->subscriptionrequestmessage_);
    std::swap(joinexistinggamemessage_, other->joinexistinggamemessage_);
    std::swap(joinnewgamemessage_, other->joinnewgamemessage_);
    std::swap(rejoinexistinggamemessage_, other->rejoinexistinggamemessage_);
    std::swap(joingameackmessage_, other->joingameackmessage_);
    std::swap(joingamefailedmessage_, other->joingamefailedmessage_);
    std::swap(gameplayerjoinedmessage_, other->gameplayerjoinedmessage_);
    std::swap(gameplayerleftmessage_, other->gameplayerleftmessage_);
    std::swap(gameadminchangedmessage_, other->gameadminchangedmessage_);
    std::swap(removedfromgamemessage_, other->removedfromgamemessage_);
    std::swap(kickplayerrequestmessage_, other->kickplayerrequestmessage_);
    std::swap(leavegamerequestmessage_, other->leavegamerequestmessage_);
    std::swap(inviteplayertogamemessage_, other->inviteplayertogamemessage_);
    std::swap(invitenotifymessage_, other->invitenotifymessage_);
    std::swap(rejectgameinvitationmessage_, other->rejectgameinvitationmessage_);
    std::swap(rejectinvnotifymessage_, other->rejectinvnotifymessage_);
    std::swap(starteventmessage_, other->starteventmessage_);
    std::swap(starteventackmessage_, other->starteventackmessage_);
    std::swap(gamestartinitialmessage_, other->gamestartinitialmessage_);
    std::swap(gamestartrejoinmessage_, other->gamestartrejoinmessage_);
    std::swap(handstartmessage_, other->handstartmessage_);
    std::swap(playersturnmessage_, other->playersturnmessage_);
    std::swap(myactionrequestmessage_, other->myactionrequestmessage_);
    std::swap(youractionrejectedmessage_, other->youractionrejectedmessage_);
    std::swap(playersactiondonemessage_, other->playersactiondonemessage_);
    std::swap(dealflopcardsmessage_, other->dealflopcardsmessage_);
    std::swap(dealturncardmessage_, other->dealturncardmessage_);
    std::swap(dealrivercardmessage_, other->dealrivercardmessage_);
    std::swap(allinshowcardsmessage_, other->allinshowcardsmessage_);
    std::swap(endofhandshowcardsmessage_, other->endofhandshowcardsmessage_);
    std::swap(endofhandhidecardsmessage_, other->endofhandhidecardsmessage_);
    std::swap(showmycardsrequestmessage_, other->showmycardsrequestmessage_);
    std::swap(afterhandshowcardsmessage_, other->afterhandshowcardsmessage_);
    std::swap(endofgamemessage_, other->endofgamemessage_);
    std::swap(playeridchangedmessage_, other->playeridchangedmessage_);
    std::swap(askkickplayermessage_, other->askkickplayermessage_);
    std::swap(askkickdeniedmessage_, other->askkickdeniedmessage_);
    std::swap(startkickpetitionmessage_, other->startkickpetitionmessage_);
    std::swap(votekickrequestmessage_, other->votekickrequestmessage_);
    std::swap(votekickreplymessage_, other->votekickreplymessage_);
    std::swap(kickpetitionupdatemessage_, other->kickpetitionupdatemessage_);
    std::swap(endkickpetitionmessage_, other->endkickpetitionmessage_);
    std::swap(statisticsmessage_, other->statisticsmessage_);
    std::swap(chatrequestmessage_, other->chatrequestmessage_);
    std::swap(chatmessage_, other->chatmessage_);
    std::swap(chatrejectmessage_, other->chatrejectmessage_);
    std::swap(dialogmessage_, other->dialogmessage_);
    std::swap(timeoutwarningmessage_, other->timeoutwarningmessage_);
    std::swap(resettimeoutmessage_, other->resettimeoutmessage_);
    std::swap(reportavatarmessage_, other->reportavatarmessage_);
    std::swap(reportavatarackmessage_, other->reportavatarackmessage_);
    std::swap(reportgamemessage_, other->reportgamemessage_);
    std::swap(reportgameackmessage_, other->reportgameackmessage_);
    std::swap(errormessage_, other->errormessage_);
    std::swap(adminremovegamemessage_, other->adminremovegamemessage_);
    std::swap(adminremovegameackmessage_, other->adminremovegameackmessage_);
    std::swap(adminbanplayermessage_, other->adminbanplayermessage_);
    std::swap(adminbanplayerackmessage_, other->adminbanplayerackmessage_);
    std::swap(gamelistspectatorjoinedmessage_, other->gamelistspectatorjoinedmessage_);
    std::swap(gamelistspectatorleftmessage_, other->gamelistspectatorleftmessage_);
    std::swap(gamespectatorjoinedmessage_, other->gamespectatorjoinedmessage_);
    std::swap(gamespectatorleftmessage_, other->gamespectatorleftmessage_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_has_bits_[1], other->_has_bits_[1]);
    std::swap(_has_bits_[2], other->_has_bits_[2]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PokerTHMessage::GetTypeName() const {
  return "PokerTHMessage";
}


// @@protoc_insertion_point(namespace_scope)

// @@protoc_insertion_point(global_scope)