text:
namespace protoc {
namespace gs_dbs {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

class GameServerRpt;
class DBServerRpt;
class KickOutRpt;
class KickOutAck;
class RandCheckReq;
class RandCheckAck;
class HeartPingReq;
class HeartPingAck;
class GetIDReq;
class GetIDAck;
class GMListRpt;
class GMListRpt_gm;
class CheckNewNameReq;
class CheckNewNameAck;
class GSState;
class GameServerStateNtf;
class AllGameServerStateRpt;
class GMMessageNtf;
class GMMessageExecuteAck;
class GetGSOnlinePlayerNumberReq;
class GSPlayerNumber;
class GSOnlinePlayerNumberRpt;
class OtherGSOnlinePlayerRpt;
class OtherGSPlayerOnlineRpt;
class OtherGSPlayerOfflineRpt;
class ChongZhiPlayer;
class OfflineChongZhiNtf;
class PlayerLeaveGameRpt;
class GetGM_ListReq;
class GetGM_ListAck;
class DBSServerCloseNtf;
class CheckInGSReq;
class CheckInGSAck;
class get_login_key_req;
class get_login_key_ack;
class login_gs_req;
class login_gs_ack;
class online_gs_rpt;
class switch_gs_lock_req;
class switch_gs_lock_ack;

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

class GameServerRpt : public ::google::protobuf::Message {
 public:
  GameServerRpt();
  virtual ~GameServerRpt();

  GameServerRpt(const GameServerRpt& from);

  inline GameServerRpt& operator=(const GameServerRpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GameServerRpt& default_instance();

  void Swap(GameServerRpt* other);

  // implements Message ----------------------------------------------

  GameServerRpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GameServerRpt& from);
  void MergeFrom(const GameServerRpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string gsid = 1;
  inline bool has_gsid() const;
  inline void clear_gsid();
  static const int kGsidFieldNumber = 1;
  inline const ::std::string& gsid() const;
  inline void set_gsid(const ::std::string& value);
  inline void set_gsid(const char* value);
  inline void set_gsid(const char* value, size_t size);
  inline ::std::string* mutable_gsid();
  inline ::std::string* release_gsid();
  inline void set_allocated_gsid(::std::string* gsid);

  // optional string gsname = 2;
  inline bool has_gsname() const;
  inline void clear_gsname();
  static const int kGsnameFieldNumber = 2;
  inline const ::std::string& gsname() const;
  inline void set_gsname(const ::std::string& value);
  inline void set_gsname(const char* value);
  inline void set_gsname(const char* value, size_t size);
  inline ::std::string* mutable_gsname();
  inline ::std::string* release_gsname();
  inline void set_allocated_gsname(::std::string* gsname);

  // optional int32 max_number = 3;
  inline bool has_max_number() const;
  inline void clear_max_number();
  static const int kMaxNumberFieldNumber = 3;
  inline ::google::protobuf::int32 max_number() const;
  inline void set_max_number(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GameServerRpt)
 private:
  inline void set_has_gsid();
  inline void clear_has_gsid();
  inline void set_has_gsname();
  inline void clear_has_gsname();
  inline void set_has_max_number();
  inline void clear_has_max_number();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* gsid_;
  ::std::string* gsname_;
  ::google::protobuf::int32 max_number_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GameServerRpt* default_instance_;
};
// -------------------------------------------------------------------

class DBServerRpt : public ::google::protobuf::Message {
 public:
  DBServerRpt();
  virtual ~DBServerRpt();

  DBServerRpt(const DBServerRpt& from);

  inline DBServerRpt& operator=(const DBServerRpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DBServerRpt& default_instance();

  void Swap(DBServerRpt* other);

  // implements Message ----------------------------------------------

  DBServerRpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DBServerRpt& from);
  void MergeFrom(const DBServerRpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string dbid = 1;
  inline bool has_dbid() const;
  inline void clear_dbid();
  static const int kDbidFieldNumber = 1;
  inline const ::std::string& dbid() const;
  inline void set_dbid(const ::std::string& value);
  inline void set_dbid(const char* value);
  inline void set_dbid(const char* value, size_t size);
  inline ::std::string* mutable_dbid();
  inline ::std::string* release_dbid();
  inline void set_allocated_dbid(::std::string* dbid);

  // optional string dbname = 2;
  inline bool has_dbname() const;
  inline void clear_dbname();
  static const int kDbnameFieldNumber = 2;
  inline const ::std::string& dbname() const;
  inline void set_dbname(const ::std::string& value);
  inline void set_dbname(const char* value);
  inline void set_dbname(const char* value, size_t size);
  inline ::std::string* mutable_dbname();
  inline ::std::string* release_dbname();
  inline void set_allocated_dbname(::std::string* dbname);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.DBServerRpt)
 private:
  inline void set_has_dbid();
  inline void clear_has_dbid();
  inline void set_has_dbname();
  inline void clear_has_dbname();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* dbid_;
  ::std::string* dbname_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static DBServerRpt* default_instance_;
};
// -------------------------------------------------------------------

class KickOutRpt : public ::google::protobuf::Message {
 public:
  KickOutRpt();
  virtual ~KickOutRpt();

  KickOutRpt(const KickOutRpt& from);

  inline KickOutRpt& operator=(const KickOutRpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const KickOutRpt& default_instance();

  void Swap(KickOutRpt* other);

  // implements Message ----------------------------------------------

  KickOutRpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const KickOutRpt& from);
  void MergeFrom(const KickOutRpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.KickOutRpt)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static KickOutRpt* default_instance_;
};
// -------------------------------------------------------------------

class KickOutAck : public ::google::protobuf::Message {
 public:
  KickOutAck();
  virtual ~KickOutAck();

  KickOutAck(const KickOutAck& from);

  inline KickOutAck& operator=(const KickOutAck& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const KickOutAck& default_instance();

  void Swap(KickOutAck* other);

  // implements Message ----------------------------------------------

  KickOutAck* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const KickOutAck& from);
  void MergeFrom(const KickOutAck& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // optional int32 error_no = 2;
  inline bool has_error_no() const;
  inline void clear_error_no();
  static const int kErrorNoFieldNumber = 2;
  inline ::google::protobuf::int32 error_no() const;
  inline void set_error_no(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.KickOutAck)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_error_no();
  inline void clear_has_error_no();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::google::protobuf::int32 error_no_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static KickOutAck* default_instance_;
};
// -------------------------------------------------------------------

class RandCheckReq : public ::google::protobuf::Message {
 public:
  RandCheckReq();
  virtual ~RandCheckReq();

  RandCheckReq(const RandCheckReq& from);

  inline RandCheckReq& operator=(const RandCheckReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RandCheckReq& default_instance();

  void Swap(RandCheckReq* other);

  // implements Message ----------------------------------------------

  RandCheckReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RandCheckReq& from);
  void MergeFrom(const RandCheckReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes key = 1;
  inline bool has_key() const;
  inline void clear_key();
  static const int kKeyFieldNumber = 1;
  inline const ::std::string& key() const;
  inline void set_key(const ::std::string& value);
  inline void set_key(const char* value);
  inline void set_key(const void* value, size_t size);
  inline ::std::string* mutable_key();
  inline ::std::string* release_key();
  inline void set_allocated_key(::std::string* key);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.RandCheckReq)
 private:
  inline void set_has_key();
  inline void clear_has_key();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* key_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static RandCheckReq* default_instance_;
};
// -------------------------------------------------------------------

class RandCheckAck : public ::google::protobuf::Message {
 public:
  RandCheckAck();
  virtual ~RandCheckAck();

  RandCheckAck(const RandCheckAck& from);

  inline RandCheckAck& operator=(const RandCheckAck& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RandCheckAck& default_instance();

  void Swap(RandCheckAck* other);

  // implements Message ----------------------------------------------

  RandCheckAck* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RandCheckAck& from);
  void MergeFrom(const RandCheckAck& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes rand_text = 1;
  inline bool has_rand_text() const;
  inline void clear_rand_text();
  static const int kRandTextFieldNumber = 1;
  inline const ::std::string& rand_text() const;
  inline void set_rand_text(const ::std::string& value);
  inline void set_rand_text(const char* value);
  inline void set_rand_text(const void* value, size_t size);
  inline ::std::string* mutable_rand_text();
  inline ::std::string* release_rand_text();
  inline void set_allocated_rand_text(::std::string* rand_text);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.RandCheckAck)
 private:
  inline void set_has_rand_text();
  inline void clear_has_rand_text();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* rand_text_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static RandCheckAck* default_instance_;
};
// -------------------------------------------------------------------

class HeartPingReq : public ::google::protobuf::Message {
 public:
  HeartPingReq();
  virtual ~HeartPingReq();

  HeartPingReq(const HeartPingReq& from);

  inline HeartPingReq& operator=(const HeartPingReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const HeartPingReq& default_instance();

  void Swap(HeartPingReq* other);

  // implements Message ----------------------------------------------

  HeartPingReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const HeartPingReq& from);
  void MergeFrom(const HeartPingReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 opt = 1;
  inline bool has_opt() const;
  inline void clear_opt();
  static const int kOptFieldNumber = 1;
  inline ::google::protobuf::int32 opt() const;
  inline void set_opt(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.HeartPingReq)
 private:
  inline void set_has_opt();
  inline void clear_has_opt();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 opt_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static HeartPingReq* default_instance_;
};
// -------------------------------------------------------------------

class HeartPingAck : public ::google::protobuf::Message {
 public:
  HeartPingAck();
  virtual ~HeartPingAck();

  HeartPingAck(const HeartPingAck& from);

  inline HeartPingAck& operator=(const HeartPingAck& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const HeartPingAck& default_instance();

  void Swap(HeartPingAck* other);

  // implements Message ----------------------------------------------

  HeartPingAck* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const HeartPingAck& from);
  void MergeFrom(const HeartPingAck& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 opt = 1;
  inline bool has_opt() const;
  inline void clear_opt();
  static const int kOptFieldNumber = 1;
  inline ::google::protobuf::int32 opt() const;
  inline void set_opt(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.HeartPingAck)
 private:
  inline void set_has_opt();
  inline void clear_has_opt();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 opt_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static HeartPingAck* default_instance_;
};
// -------------------------------------------------------------------

class GetIDReq : public ::google::protobuf::Message {
 public:
  GetIDReq();
  virtual ~GetIDReq();

  GetIDReq(const GetIDReq& from);

  inline GetIDReq& operator=(const GetIDReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetIDReq& default_instance();

  void Swap(GetIDReq* other);

  // implements Message ----------------------------------------------

  GetIDReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetIDReq& from);
  void MergeFrom(const GetIDReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 kind = 1;
  inline bool has_kind() const;
  inline void clear_kind();
  static const int kKindFieldNumber = 1;
  inline ::google::protobuf::uint32 kind() const;
  inline void set_kind(::google::protobuf::uint32 value);

  // optional uint32 number = 2;
  inline bool has_number() const;
  inline void clear_number();
  static const int kNumberFieldNumber = 2;
  inline ::google::protobuf::uint32 number() const;
  inline void set_number(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GetIDReq)
 private:
  inline void set_has_kind();
  inline void clear_has_kind();
  inline void set_has_number();
  inline void clear_has_number();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 kind_;
  ::google::protobuf::uint32 number_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GetIDReq* default_instance_;
};
// -------------------------------------------------------------------

class GetIDAck : public ::google::protobuf::Message {
 public:
  GetIDAck();
  virtual ~GetIDAck();

  GetIDAck(const GetIDAck& from);

  inline GetIDAck& operator=(const GetIDAck& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetIDAck& default_instance();

  void Swap(GetIDAck* other);

  // implements Message ----------------------------------------------

  GetIDAck* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetIDAck& from);
  void MergeFrom(const GetIDAck& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 kind = 1;
  inline bool has_kind() const;
  inline void clear_kind();
  static const int kKindFieldNumber = 1;
  inline ::google::protobuf::uint32 kind() const;
  inline void set_kind(::google::protobuf::uint32 value);

  // optional uint32 number = 2;
  inline bool has_number() const;
  inline void clear_number();
  static const int kNumberFieldNumber = 2;
  inline ::google::protobuf::uint32 number() const;
  inline void set_number(::google::protobuf::uint32 value);

  // optional uint64 begin_id = 3;
  inline bool has_begin_id() const;
  inline void clear_begin_id();
  static const int kBeginIdFieldNumber = 3;
  inline ::google::protobuf::uint64 begin_id() const;
  inline void set_begin_id(::google::protobuf::uint64 value);

  // optional uint64 end_id = 4;
  inline bool has_end_id() const;
  inline void clear_end_id();
  static const int kEndIdFieldNumber = 4;
  inline ::google::protobuf::uint64 end_id() const;
  inline void set_end_id(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GetIDAck)
 private:
  inline void set_has_kind();
  inline void clear_has_kind();
  inline void set_has_number();
  inline void clear_has_number();
  inline void set_has_begin_id();
  inline void clear_has_begin_id();
  inline void set_has_end_id();
  inline void clear_has_end_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 kind_;
  ::google::protobuf::uint32 number_;
  ::google::protobuf::uint64 begin_id_;
  ::google::protobuf::uint64 end_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GetIDAck* default_instance_;
};
// -------------------------------------------------------------------

class GMListRpt_gm : public ::google::protobuf::Message {
 public:
  GMListRpt_gm();
  virtual ~GMListRpt_gm();

  GMListRpt_gm(const GMListRpt_gm& from);

  inline GMListRpt_gm& operator=(const GMListRpt_gm& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GMListRpt_gm& default_instance();

  void Swap(GMListRpt_gm* other);

  // implements Message ----------------------------------------------

  GMListRpt_gm* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GMListRpt_gm& from);
  void MergeFrom(const GMListRpt_gm& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 gm_level = 2;
  inline bool has_gm_level() const;
  inline void clear_gm_level();
  static const int kGmLevelFieldNumber = 2;
  inline ::google::protobuf::int32 gm_level() const;
  inline void set_gm_level(::google::protobuf::int32 value);

  // optional string account = 3;
  inline bool has_account() const;
  inline void clear_account();
  static const int kAccountFieldNumber = 3;
  inline const ::std::string& account() const;
  inline void set_account(const ::std::string& value);
  inline void set_account(const char* value);
  inline void set_account(const char* value, size_t size);
  inline ::std::string* mutable_account();
  inline ::std::string* release_account();
  inline void set_allocated_account(::std::string* account);

  // optional string password = 4;
  inline bool has_password() const;
  inline void clear_password();
  static const int kPasswordFieldNumber = 4;
  inline const ::std::string& password() const;
  inline void set_password(const ::std::string& value);
  inline void set_password(const char* value);
  inline void set_password(const char* value, size_t size);
  inline ::std::string* mutable_password();
  inline ::std::string* release_password();
  inline void set_allocated_password(::std::string* password);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GMListRpt.gm)
 private:
  inline void set_has_gm_level();
  inline void clear_has_gm_level();
  inline void set_has_account();
  inline void clear_has_account();
  inline void set_has_password();
  inline void clear_has_password();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* account_;
  ::std::string* password_;
  ::google::protobuf::int32 gm_level_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GMListRpt_gm* default_instance_;
};
// -------------------------------------------------------------------

class GMListRpt : public ::google::protobuf::Message {
 public:
  GMListRpt();
  virtual ~GMListRpt();

  GMListRpt(const GMListRpt& from);

  inline GMListRpt& operator=(const GMListRpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GMListRpt& default_instance();

  void Swap(GMListRpt* other);

  // implements Message ----------------------------------------------

  GMListRpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GMListRpt& from);
  void MergeFrom(const GMListRpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  typedef GMListRpt_gm gm;

  // accessors -------------------------------------------------------

  // repeated .protoc.gs_dbs.GMListRpt.gm table = 1;
  inline int table_size() const;
  inline void clear_table();
  static const int kTableFieldNumber = 1;
  inline const ::protoc::gs_dbs::GMListRpt_gm& table(int index) const;
  inline ::protoc::gs_dbs::GMListRpt_gm* mutable_table(int index);
  inline ::protoc::gs_dbs::GMListRpt_gm* add_table();
  inline const ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GMListRpt_gm >&
      table() const;
  inline ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GMListRpt_gm >*
      mutable_table();

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GMListRpt)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GMListRpt_gm > table_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GMListRpt* default_instance_;
};
// -------------------------------------------------------------------

class CheckNewNameReq : public ::google::protobuf::Message {
 public:
  CheckNewNameReq();
  virtual ~CheckNewNameReq();

  CheckNewNameReq(const CheckNewNameReq& from);

  inline CheckNewNameReq& operator=(const CheckNewNameReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CheckNewNameReq& default_instance();

  void Swap(CheckNewNameReq* other);

  // implements Message ----------------------------------------------

  CheckNewNameReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CheckNewNameReq& from);
  void MergeFrom(const CheckNewNameReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // required string newname = 2;
  inline bool has_newname() const;
  inline void clear_newname();
  static const int kNewnameFieldNumber = 2;
  inline const ::std::string& newname() const;
  inline void set_newname(const ::std::string& value);
  inline void set_newname(const char* value);
  inline void set_newname(const char* value, size_t size);
  inline ::std::string* mutable_newname();
  inline ::std::string* release_newname();
  inline void set_allocated_newname(::std::string* newname);

  // optional uint32 head_pic_id = 3;
  inline bool has_head_pic_id() const;
  inline void clear_head_pic_id();
  static const int kHeadPicIdFieldNumber = 3;
  inline ::google::protobuf::uint32 head_pic_id() const;
  inline void set_head_pic_id(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.CheckNewNameReq)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_newname();
  inline void clear_has_newname();
  inline void set_has_head_pic_id();
  inline void clear_has_head_pic_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::std::string* newname_;
  ::google::protobuf::uint32 head_pic_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static CheckNewNameReq* default_instance_;
};
// -------------------------------------------------------------------

class CheckNewNameAck : public ::google::protobuf::Message {
 public:
  CheckNewNameAck();
  virtual ~CheckNewNameAck();

  CheckNewNameAck(const CheckNewNameAck& from);

  inline CheckNewNameAck& operator=(const CheckNewNameAck& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CheckNewNameAck& default_instance();

  void Swap(CheckNewNameAck* other);

  // implements Message ----------------------------------------------

  CheckNewNameAck* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CheckNewNameAck& from);
  void MergeFrom(const CheckNewNameAck& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // required string newname = 2;
  inline bool has_newname() const;
  inline void clear_newname();
  static const int kNewnameFieldNumber = 2;
  inline const ::std::string& newname() const;
  inline void set_newname(const ::std::string& value);
  inline void set_newname(const char* value);
  inline void set_newname(const char* value, size_t size);
  inline ::std::string* mutable_newname();
  inline ::std::string* release_newname();
  inline void set_allocated_newname(::std::string* newname);

  // optional uint32 head_pic_id = 3;
  inline bool has_head_pic_id() const;
  inline void clear_head_pic_id();
  static const int kHeadPicIdFieldNumber = 3;
  inline ::google::protobuf::uint32 head_pic_id() const;
  inline void set_head_pic_id(::google::protobuf::uint32 value);

  // required int32 error_no = 4;
  inline bool has_error_no() const;
  inline void clear_error_no();
  static const int kErrorNoFieldNumber = 4;
  inline ::google::protobuf::int32 error_no() const;
  inline void set_error_no(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.CheckNewNameAck)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_newname();
  inline void clear_has_newname();
  inline void set_has_head_pic_id();
  inline void clear_has_head_pic_id();
  inline void set_has_error_no();
  inline void clear_has_error_no();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::std::string* newname_;
  ::google::protobuf::uint32 head_pic_id_;
  ::google::protobuf::int32 error_no_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static CheckNewNameAck* default_instance_;
};
// -------------------------------------------------------------------

class GSState : public ::google::protobuf::Message {
 public:
  GSState();
  virtual ~GSState();

  GSState(const GSState& from);

  inline GSState& operator=(const GSState& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GSState& default_instance();

  void Swap(GSState* other);

  // implements Message ----------------------------------------------

  GSState* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GSState& from);
  void MergeFrom(const GSState& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string gsid = 1;
  inline bool has_gsid() const;
  inline void clear_gsid();
  static const int kGsidFieldNumber = 1;
  inline const ::std::string& gsid() const;
  inline void set_gsid(const ::std::string& value);
  inline void set_gsid(const char* value);
  inline void set_gsid(const char* value, size_t size);
  inline ::std::string* mutable_gsid();
  inline ::std::string* release_gsid();
  inline void set_allocated_gsid(::std::string* gsid);

  // optional string gsname = 2;
  inline bool has_gsname() const;
  inline void clear_gsname();
  static const int kGsnameFieldNumber = 2;
  inline const ::std::string& gsname() const;
  inline void set_gsname(const ::std::string& value);
  inline void set_gsname(const char* value);
  inline void set_gsname(const char* value, size_t size);
  inline ::std::string* mutable_gsname();
  inline ::std::string* release_gsname();
  inline void set_allocated_gsname(::std::string* gsname);

  // optional int32 state = 3;
  inline bool has_state() const;
  inline void clear_state();
  static const int kStateFieldNumber = 3;
  inline ::google::protobuf::int32 state() const;
  inline void set_state(::google::protobuf::int32 value);

  // optional int32 cur_online_number = 4;
  inline bool has_cur_online_number() const;
  inline void clear_cur_online_number();
  static const int kCurOnlineNumberFieldNumber = 4;
  inline ::google::protobuf::int32 cur_online_number() const;
  inline void set_cur_online_number(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GSState)
 private:
  inline void set_has_gsid();
  inline void clear_has_gsid();
  inline void set_has_gsname();
  inline void clear_has_gsname();
  inline void set_has_state();
  inline void clear_has_state();
  inline void set_has_cur_online_number();
  inline void clear_has_cur_online_number();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* gsid_;
  ::std::string* gsname_;
  ::google::protobuf::int32 state_;
  ::google::protobuf::int32 cur_online_number_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GSState* default_instance_;
};
// -------------------------------------------------------------------

class GameServerStateNtf : public ::google::protobuf::Message {
 public:
  GameServerStateNtf();
  virtual ~GameServerStateNtf();

  GameServerStateNtf(const GameServerStateNtf& from);

  inline GameServerStateNtf& operator=(const GameServerStateNtf& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GameServerStateNtf& default_instance();

  void Swap(GameServerStateNtf* other);

  // implements Message ----------------------------------------------

  GameServerStateNtf* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GameServerStateNtf& from);
  void MergeFrom(const GameServerStateNtf& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protoc.gs_dbs.GSState gs = 1;
  inline bool has_gs() const;
  inline void clear_gs();
  static const int kGsFieldNumber = 1;
  inline const ::protoc::gs_dbs::GSState& gs() const;
  inline ::protoc::gs_dbs::GSState* mutable_gs();
  inline ::protoc::gs_dbs::GSState* release_gs();
  inline void set_allocated_gs(::protoc::gs_dbs::GSState* gs);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GameServerStateNtf)
 private:
  inline void set_has_gs();
  inline void clear_has_gs();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::protoc::gs_dbs::GSState* gs_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GameServerStateNtf* default_instance_;
};
// -------------------------------------------------------------------

class AllGameServerStateRpt : public ::google::protobuf::Message {
 public:
  AllGameServerStateRpt();
  virtual ~AllGameServerStateRpt();

  AllGameServerStateRpt(const AllGameServerStateRpt& from);

  inline AllGameServerStateRpt& operator=(const AllGameServerStateRpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AllGameServerStateRpt& default_instance();

  void Swap(AllGameServerStateRpt* other);

  // implements Message ----------------------------------------------

  AllGameServerStateRpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AllGameServerStateRpt& from);
  void MergeFrom(const AllGameServerStateRpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .protoc.gs_dbs.GSState gs = 1;
  inline int gs_size() const;
  inline void clear_gs();
  static const int kGsFieldNumber = 1;
  inline const ::protoc::gs_dbs::GSState& gs(int index) const;
  inline ::protoc::gs_dbs::GSState* mutable_gs(int index);
  inline ::protoc::gs_dbs::GSState* add_gs();
  inline const ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GSState >&
      gs() const;
  inline ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GSState >*
      mutable_gs();

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.AllGameServerStateRpt)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GSState > gs_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static AllGameServerStateRpt* default_instance_;
};
// -------------------------------------------------------------------

class GMMessageNtf : public ::google::protobuf::Message {
 public:
  GMMessageNtf();
  virtual ~GMMessageNtf();

  GMMessageNtf(const GMMessageNtf& from);

  inline GMMessageNtf& operator=(const GMMessageNtf& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GMMessageNtf& default_instance();

  void Swap(GMMessageNtf* other);

  // implements Message ----------------------------------------------

  GMMessageNtf* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GMMessageNtf& from);
  void MergeFrom(const GMMessageNtf& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // optional string account = 2;
  inline bool has_account() const;
  inline void clear_account();
  static const int kAccountFieldNumber = 2;
  inline const ::std::string& account() const;
  inline void set_account(const ::std::string& value);
  inline void set_account(const char* value);
  inline void set_account(const char* value, size_t size);
  inline ::std::string* mutable_account();
  inline ::std::string* release_account();
  inline void set_allocated_account(::std::string* account);

  // optional string playername = 3;
  inline bool has_playername() const;
  inline void clear_playername();
  static const int kPlayernameFieldNumber = 3;
  inline const ::std::string& playername() const;
  inline void set_playername(const ::std::string& value);
  inline void set_playername(const char* value);
  inline void set_playername(const char* value, size_t size);
  inline ::std::string* mutable_playername();
  inline ::std::string* release_playername();
  inline void set_allocated_playername(::std::string* playername);

  // optional string ip = 4;
  inline bool has_ip() const;
  inline void clear_ip();
  static const int kIpFieldNumber = 4;
  inline const ::std::string& ip() const;
  inline void set_ip(const ::std::string& value);
  inline void set_ip(const char* value);
  inline void set_ip(const char* value, size_t size);
  inline ::std::string* mutable_ip();
  inline ::std::string* release_ip();
  inline void set_allocated_ip(::std::string* ip);

  // optional string src_gs_id = 5;
  inline bool has_src_gs_id() const;
  inline void clear_src_gs_id();
  static const int kSrcGsIdFieldNumber = 5;
  inline const ::std::string& src_gs_id() const;
  inline void set_src_gs_id(const ::std::string& value);
  inline void set_src_gs_id(const char* value);
  inline void set_src_gs_id(const char* value, size_t size);
  inline ::std::string* mutable_src_gs_id();
  inline ::std::string* release_src_gs_id();
  inline void set_allocated_src_gs_id(::std::string* src_gs_id);

  // optional string cmd = 6;
  inline bool has_cmd() const;
  inline void clear_cmd();
  static const int kCmdFieldNumber = 6;
  inline const ::std::string& cmd() const;
  inline void set_cmd(const ::std::string& value);
  inline void set_cmd(const char* value);
  inline void set_cmd(const char* value, size_t size);
  inline ::std::string* mutable_cmd();
  inline ::std::string* release_cmd();
  inline void set_allocated_cmd(::std::string* cmd);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GMMessageNtf)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_account();
  inline void clear_has_account();
  inline void set_has_playername();
  inline void clear_has_playername();
  inline void set_has_ip();
  inline void clear_has_ip();
  inline void set_has_src_gs_id();
  inline void clear_has_src_gs_id();
  inline void set_has_cmd();
  inline void clear_has_cmd();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::std::string* account_;
  ::std::string* playername_;
  ::std::string* ip_;
  ::std::string* src_gs_id_;
  ::std::string* cmd_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GMMessageNtf* default_instance_;
};
// -------------------------------------------------------------------

class GMMessageExecuteAck : public ::google::protobuf::Message {
 public:
  GMMessageExecuteAck();
  virtual ~GMMessageExecuteAck();

  GMMessageExecuteAck(const GMMessageExecuteAck& from);

  inline GMMessageExecuteAck& operator=(const GMMessageExecuteAck& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GMMessageExecuteAck& default_instance();

  void Swap(GMMessageExecuteAck* other);

  // implements Message ----------------------------------------------

  GMMessageExecuteAck* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GMMessageExecuteAck& from);
  void MergeFrom(const GMMessageExecuteAck& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // optional string account = 2;
  inline bool has_account() const;
  inline void clear_account();
  static const int kAccountFieldNumber = 2;
  inline const ::std::string& account() const;
  inline void set_account(const ::std::string& value);
  inline void set_account(const char* value);
  inline void set_account(const char* value, size_t size);
  inline ::std::string* mutable_account();
  inline ::std::string* release_account();
  inline void set_allocated_account(::std::string* account);

  // optional string playername = 3;
  inline bool has_playername() const;
  inline void clear_playername();
  static const int kPlayernameFieldNumber = 3;
  inline const ::std::string& playername() const;
  inline void set_playername(const ::std::string& value);
  inline void set_playername(const char* value);
  inline void set_playername(const char* value, size_t size);
  inline ::std::string* mutable_playername();
  inline ::std::string* release_playername();
  inline void set_allocated_playername(::std::string* playername);

  // optional string cmd = 4;
  inline bool has_cmd() const;
  inline void clear_cmd();
  static const int kCmdFieldNumber = 4;
  inline const ::std::string& cmd() const;
  inline void set_cmd(const ::std::string& value);
  inline void set_cmd(const char* value);
  inline void set_cmd(const char* value, size_t size);
  inline ::std::string* mutable_cmd();
  inline ::std::string* release_cmd();
  inline void set_allocated_cmd(::std::string* cmd);

  // optional string src_gs_id = 5;
  inline bool has_src_gs_id() const;
  inline void clear_src_gs_id();
  static const int kSrcGsIdFieldNumber = 5;
  inline const ::std::string& src_gs_id() const;
  inline void set_src_gs_id(const ::std::string& value);
  inline void set_src_gs_id(const char* value);
  inline void set_src_gs_id(const char* value, size_t size);
  inline ::std::string* mutable_src_gs_id();
  inline ::std::string* release_src_gs_id();
  inline void set_allocated_src_gs_id(::std::string* src_gs_id);

  // optional string dest_gs_id = 6;
  inline bool has_dest_gs_id() const;
  inline void clear_dest_gs_id();
  static const int kDestGsIdFieldNumber = 6;
  inline const ::std::string& dest_gs_id() const;
  inline void set_dest_gs_id(const ::std::string& value);
  inline void set_dest_gs_id(const char* value);
  inline void set_dest_gs_id(const char* value, size_t size);
  inline ::std::string* mutable_dest_gs_id();
  inline ::std::string* release_dest_gs_id();
  inline void set_allocated_dest_gs_id(::std::string* dest_gs_id);

  // optional int32 to_client_message_id = 7;
  inline bool has_to_client_message_id() const;
  inline void clear_to_client_message_id();
  static const int kToClientMessageIdFieldNumber = 7;
  inline ::google::protobuf::int32 to_client_message_id() const;
  inline void set_to_client_message_id(::google::protobuf::int32 value);

  // optional bytes to_client_message = 8;
  inline bool has_to_client_message() const;
  inline void clear_to_client_message();
  static const int kToClientMessageFieldNumber = 8;
  inline const ::std::string& to_client_message() const;
  inline void set_to_client_message(const ::std::string& value);
  inline void set_to_client_message(const char* value);
  inline void set_to_client_message(const void* value, size_t size);
  inline ::std::string* mutable_to_client_message();
  inline ::std::string* release_to_client_message();
  inline void set_allocated_to_client_message(::std::string* to_client_message);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GMMessageExecuteAck)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_account();
  inline void clear_has_account();
  inline void set_has_playername();
  inline void clear_has_playername();
  inline void set_has_cmd();
  inline void clear_has_cmd();
  inline void set_has_src_gs_id();
  inline void clear_has_src_gs_id();
  inline void set_has_dest_gs_id();
  inline void clear_has_dest_gs_id();
  inline void set_has_to_client_message_id();
  inline void clear_has_to_client_message_id();
  inline void set_has_to_client_message();
  inline void clear_has_to_client_message();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::std::string* account_;
  ::std::string* playername_;
  ::std::string* cmd_;
  ::std::string* src_gs_id_;
  ::std::string* dest_gs_id_;
  ::std::string* to_client_message_;
  ::google::protobuf::int32 to_client_message_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GMMessageExecuteAck* default_instance_;
};
// -------------------------------------------------------------------

class GetGSOnlinePlayerNumberReq : public ::google::protobuf::Message {
 public:
  GetGSOnlinePlayerNumberReq();
  virtual ~GetGSOnlinePlayerNumberReq();

  GetGSOnlinePlayerNumberReq(const GetGSOnlinePlayerNumberReq& from);

  inline GetGSOnlinePlayerNumberReq& operator=(const GetGSOnlinePlayerNumberReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetGSOnlinePlayerNumberReq& default_instance();

  void Swap(GetGSOnlinePlayerNumberReq* other);

  // implements Message ----------------------------------------------

  GetGSOnlinePlayerNumberReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetGSOnlinePlayerNumberReq& from);
  void MergeFrom(const GetGSOnlinePlayerNumberReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 kind = 1;
  inline bool has_kind() const;
  inline void clear_kind();
  static const int kKindFieldNumber = 1;
  inline ::google::protobuf::int32 kind() const;
  inline void set_kind(::google::protobuf::int32 value);

  // optional uint64 playerid = 2;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 2;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GetGSOnlinePlayerNumberReq)
 private:
  inline void set_has_kind();
  inline void clear_has_kind();
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::google::protobuf::int32 kind_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GetGSOnlinePlayerNumberReq* default_instance_;
};
// -------------------------------------------------------------------

class GSPlayerNumber : public ::google::protobuf::Message {
 public:
  GSPlayerNumber();
  virtual ~GSPlayerNumber();

  GSPlayerNumber(const GSPlayerNumber& from);

  inline GSPlayerNumber& operator=(const GSPlayerNumber& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GSPlayerNumber& default_instance();

  void Swap(GSPlayerNumber* other);

  // implements Message ----------------------------------------------

  GSPlayerNumber* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GSPlayerNumber& from);
  void MergeFrom(const GSPlayerNumber& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string gs = 1;
  inline bool has_gs() const;
  inline void clear_gs();
  static const int kGsFieldNumber = 1;
  inline const ::std::string& gs() const;
  inline void set_gs(const ::std::string& value);
  inline void set_gs(const char* value);
  inline void set_gs(const char* value, size_t size);
  inline ::std::string* mutable_gs();
  inline ::std::string* release_gs();
  inline void set_allocated_gs(::std::string* gs);

  // optional string gsname = 2;
  inline bool has_gsname() const;
  inline void clear_gsname();
  static const int kGsnameFieldNumber = 2;
  inline const ::std::string& gsname() const;
  inline void set_gsname(const ::std::string& value);
  inline void set_gsname(const char* value);
  inline void set_gsname(const char* value, size_t size);
  inline ::std::string* mutable_gsname();
  inline ::std::string* release_gsname();
  inline void set_allocated_gsname(::std::string* gsname);

  // optional int32 number = 3;
  inline bool has_number() const;
  inline void clear_number();
  static const int kNumberFieldNumber = 3;
  inline ::google::protobuf::int32 number() const;
  inline void set_number(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GSPlayerNumber)
 private:
  inline void set_has_gs();
  inline void clear_has_gs();
  inline void set_has_gsname();
  inline void clear_has_gsname();
  inline void set_has_number();
  inline void clear_has_number();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* gs_;
  ::std::string* gsname_;
  ::google::protobuf::int32 number_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GSPlayerNumber* default_instance_;
};
// -------------------------------------------------------------------

class GSOnlinePlayerNumberRpt : public ::google::protobuf::Message {
 public:
  GSOnlinePlayerNumberRpt();
  virtual ~GSOnlinePlayerNumberRpt();

  GSOnlinePlayerNumberRpt(const GSOnlinePlayerNumberRpt& from);

  inline GSOnlinePlayerNumberRpt& operator=(const GSOnlinePlayerNumberRpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GSOnlinePlayerNumberRpt& default_instance();

  void Swap(GSOnlinePlayerNumberRpt* other);

  // implements Message ----------------------------------------------

  GSOnlinePlayerNumberRpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GSOnlinePlayerNumberRpt& from);
  void MergeFrom(const GSOnlinePlayerNumberRpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .protoc.gs_dbs.GSPlayerNumber gsn = 1;
  inline int gsn_size() const;
  inline void clear_gsn();
  static const int kGsnFieldNumber = 1;
  inline const ::protoc::gs_dbs::GSPlayerNumber& gsn(int index) const;
  inline ::protoc::gs_dbs::GSPlayerNumber* mutable_gsn(int index);
  inline ::protoc::gs_dbs::GSPlayerNumber* add_gsn();
  inline const ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GSPlayerNumber >&
      gsn() const;
  inline ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GSPlayerNumber >*
      mutable_gsn();

  // optional uint64 playerid = 2;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 2;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GSOnlinePlayerNumberRpt)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GSPlayerNumber > gsn_;
  ::google::protobuf::uint64 playerid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GSOnlinePlayerNumberRpt* default_instance_;
};
// -------------------------------------------------------------------

class OtherGSOnlinePlayerRpt : public ::google::protobuf::Message {
 public:
  OtherGSOnlinePlayerRpt();
  virtual ~OtherGSOnlinePlayerRpt();

  OtherGSOnlinePlayerRpt(const OtherGSOnlinePlayerRpt& from);

  inline OtherGSOnlinePlayerRpt& operator=(const OtherGSOnlinePlayerRpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const OtherGSOnlinePlayerRpt& default_instance();

  void Swap(OtherGSOnlinePlayerRpt* other);

  // implements Message ----------------------------------------------

  OtherGSOnlinePlayerRpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const OtherGSOnlinePlayerRpt& from);
  void MergeFrom(const OtherGSOnlinePlayerRpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 isonline = 1;
  inline bool has_isonline() const;
  inline void clear_isonline();
  static const int kIsonlineFieldNumber = 1;
  inline ::google::protobuf::int32 isonline() const;
  inline void set_isonline(::google::protobuf::int32 value);

  // repeated uint64 playerid = 2;
  inline int playerid_size() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 2;
  inline ::google::protobuf::uint64 playerid(int index) const;
  inline void set_playerid(int index, ::google::protobuf::uint64 value);
  inline void add_playerid(::google::protobuf::uint64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      playerid() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_playerid();

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.OtherGSOnlinePlayerRpt)
 private:
  inline void set_has_isonline();
  inline void clear_has_isonline();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > playerid_;
  ::google::protobuf::int32 isonline_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static OtherGSOnlinePlayerRpt* default_instance_;
};
// -------------------------------------------------------------------

class OtherGSPlayerOnlineRpt : public ::google::protobuf::Message {
 public:
  OtherGSPlayerOnlineRpt();
  virtual ~OtherGSPlayerOnlineRpt();

  OtherGSPlayerOnlineRpt(const OtherGSPlayerOnlineRpt& from);

  inline OtherGSPlayerOnlineRpt& operator=(const OtherGSPlayerOnlineRpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const OtherGSPlayerOnlineRpt& default_instance();

  void Swap(OtherGSPlayerOnlineRpt* other);

  // implements Message ----------------------------------------------

  OtherGSPlayerOnlineRpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const OtherGSPlayerOnlineRpt& from);
  void MergeFrom(const OtherGSPlayerOnlineRpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.OtherGSPlayerOnlineRpt)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static OtherGSPlayerOnlineRpt* default_instance_;
};
// -------------------------------------------------------------------

class OtherGSPlayerOfflineRpt : public ::google::protobuf::Message {
 public:
  OtherGSPlayerOfflineRpt();
  virtual ~OtherGSPlayerOfflineRpt();

  OtherGSPlayerOfflineRpt(const OtherGSPlayerOfflineRpt& from);

  inline OtherGSPlayerOfflineRpt& operator=(const OtherGSPlayerOfflineRpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const OtherGSPlayerOfflineRpt& default_instance();

  void Swap(OtherGSPlayerOfflineRpt* other);

  // implements Message ----------------------------------------------

  OtherGSPlayerOfflineRpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const OtherGSPlayerOfflineRpt& from);
  void MergeFrom(const OtherGSPlayerOfflineRpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.OtherGSPlayerOfflineRpt)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static OtherGSPlayerOfflineRpt* default_instance_;
};
// -------------------------------------------------------------------

class ChongZhiPlayer : public ::google::protobuf::Message {
 public:
  ChongZhiPlayer();
  virtual ~ChongZhiPlayer();

  ChongZhiPlayer(const ChongZhiPlayer& from);

  inline ChongZhiPlayer& operator=(const ChongZhiPlayer& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ChongZhiPlayer& default_instance();

  void Swap(ChongZhiPlayer* other);

  // implements Message ----------------------------------------------

  ChongZhiPlayer* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ChongZhiPlayer& from);
  void MergeFrom(const ChongZhiPlayer& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 transaction_id = 1;
  inline bool has_transaction_id() const;
  inline void clear_transaction_id();
  static const int kTransactionIdFieldNumber = 1;
  inline ::google::protobuf::uint64 transaction_id() const;
  inline void set_transaction_id(::google::protobuf::uint64 value);

  // optional uint64 playerid = 2;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 2;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.ChongZhiPlayer)
 private:
  inline void set_has_transaction_id();
  inline void clear_has_transaction_id();
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 transaction_id_;
  ::google::protobuf::uint64 playerid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static ChongZhiPlayer* default_instance_;
};
// -------------------------------------------------------------------

class OfflineChongZhiNtf : public ::google::protobuf::Message {
 public:
  OfflineChongZhiNtf();
  virtual ~OfflineChongZhiNtf();

  OfflineChongZhiNtf(const OfflineChongZhiNtf& from);

  inline OfflineChongZhiNtf& operator=(const OfflineChongZhiNtf& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const OfflineChongZhiNtf& default_instance();

  void Swap(OfflineChongZhiNtf* other);

  // implements Message ----------------------------------------------

  OfflineChongZhiNtf* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const OfflineChongZhiNtf& from);
  void MergeFrom(const OfflineChongZhiNtf& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 area_no = 1;
  inline bool has_area_no() const;
  inline void clear_area_no();
  static const int kAreaNoFieldNumber = 1;
  inline ::google::protobuf::uint32 area_no() const;
  inline void set_area_no(::google::protobuf::uint32 value);

  // repeated .protoc.gs_dbs.ChongZhiPlayer chongzhi_user = 2;
  inline int chongzhi_user_size() const;
  inline void clear_chongzhi_user();
  static const int kChongzhiUserFieldNumber = 2;
  inline const ::protoc::gs_dbs::ChongZhiPlayer& chongzhi_user(int index) const;
  inline ::protoc::gs_dbs::ChongZhiPlayer* mutable_chongzhi_user(int index);
  inline ::protoc::gs_dbs::ChongZhiPlayer* add_chongzhi_user();
  inline const ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::ChongZhiPlayer >&
      chongzhi_user() const;
  inline ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::ChongZhiPlayer >*
      mutable_chongzhi_user();

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.OfflineChongZhiNtf)
 private:
  inline void set_has_area_no();
  inline void clear_has_area_no();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::ChongZhiPlayer > chongzhi_user_;
  ::google::protobuf::uint32 area_no_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static OfflineChongZhiNtf* default_instance_;
};
// -------------------------------------------------------------------

class PlayerLeaveGameRpt : public ::google::protobuf::Message {
 public:
  PlayerLeaveGameRpt();
  virtual ~PlayerLeaveGameRpt();

  PlayerLeaveGameRpt(const PlayerLeaveGameRpt& from);

  inline PlayerLeaveGameRpt& operator=(const PlayerLeaveGameRpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PlayerLeaveGameRpt& default_instance();

  void Swap(PlayerLeaveGameRpt* other);

  // implements Message ----------------------------------------------

  PlayerLeaveGameRpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PlayerLeaveGameRpt& from);
  void MergeFrom(const PlayerLeaveGameRpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.PlayerLeaveGameRpt)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static PlayerLeaveGameRpt* default_instance_;
};
// -------------------------------------------------------------------

class GetGM_ListReq : public ::google::protobuf::Message {
 public:
  GetGM_ListReq();
  virtual ~GetGM_ListReq();

  GetGM_ListReq(const GetGM_ListReq& from);

  inline GetGM_ListReq& operator=(const GetGM_ListReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetGM_ListReq& default_instance();

  void Swap(GetGM_ListReq* other);

  // implements Message ----------------------------------------------

  GetGM_ListReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetGM_ListReq& from);
  void MergeFrom(const GetGM_ListReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GetGM_ListReq)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GetGM_ListReq* default_instance_;
};
// -------------------------------------------------------------------

class GetGM_ListAck : public ::google::protobuf::Message {
 public:
  GetGM_ListAck();
  virtual ~GetGM_ListAck();

  GetGM_ListAck(const GetGM_ListAck& from);

  inline GetGM_ListAck& operator=(const GetGM_ListAck& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GetGM_ListAck& default_instance();

  void Swap(GetGM_ListAck* other);

  // implements Message ----------------------------------------------

  GetGM_ListAck* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetGM_ListAck& from);
  void MergeFrom(const GetGM_ListAck& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // optional int32 err_no = 2;
  inline bool has_err_no() const;
  inline void clear_err_no();
  static const int kErrNoFieldNumber = 2;
  inline ::google::protobuf::int32 err_no() const;
  inline void set_err_no(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.GetGM_ListAck)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_err_no();
  inline void clear_has_err_no();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::google::protobuf::int32 err_no_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static GetGM_ListAck* default_instance_;
};
// -------------------------------------------------------------------

class DBSServerCloseNtf : public ::google::protobuf::Message {
 public:
  DBSServerCloseNtf();
  virtual ~DBSServerCloseNtf();

  DBSServerCloseNtf(const DBSServerCloseNtf& from);

  inline DBSServerCloseNtf& operator=(const DBSServerCloseNtf& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DBSServerCloseNtf& default_instance();

  void Swap(DBSServerCloseNtf* other);

  // implements Message ----------------------------------------------

  DBSServerCloseNtf* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DBSServerCloseNtf& from);
  void MergeFrom(const DBSServerCloseNtf& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.DBSServerCloseNtf)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static DBSServerCloseNtf* default_instance_;
};
// -------------------------------------------------------------------

class CheckInGSReq : public ::google::protobuf::Message {
 public:
  CheckInGSReq();
  virtual ~CheckInGSReq();

  CheckInGSReq(const CheckInGSReq& from);

  inline CheckInGSReq& operator=(const CheckInGSReq& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CheckInGSReq& default_instance();

  void Swap(CheckInGSReq* other);

  // implements Message ----------------------------------------------

  CheckInGSReq* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CheckInGSReq& from);
  void MergeFrom(const CheckInGSReq& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 3;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 3;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.CheckInGSReq)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static CheckInGSReq* default_instance_;
};
// -------------------------------------------------------------------

class CheckInGSAck : public ::google::protobuf::Message {
 public:
  CheckInGSAck();
  virtual ~CheckInGSAck();

  CheckInGSAck(const CheckInGSAck& from);

  inline CheckInGSAck& operator=(const CheckInGSAck& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CheckInGSAck& default_instance();

  void Swap(CheckInGSAck* other);

  // implements Message ----------------------------------------------

  CheckInGSAck* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CheckInGSAck& from);
  void MergeFrom(const CheckInGSAck& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 3;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 3;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.CheckInGSAck)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static CheckInGSAck* default_instance_;
};
// -------------------------------------------------------------------

class get_login_key_req : public ::google::protobuf::Message {
 public:
  get_login_key_req();
  virtual ~get_login_key_req();

  get_login_key_req(const get_login_key_req& from);

  inline get_login_key_req& operator=(const get_login_key_req& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const get_login_key_req& default_instance();

  void Swap(get_login_key_req* other);

  // implements Message ----------------------------------------------

  get_login_key_req* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const get_login_key_req& from);
  void MergeFrom(const get_login_key_req& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.get_login_key_req)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static get_login_key_req* default_instance_;
};
// -------------------------------------------------------------------

class get_login_key_ack : public ::google::protobuf::Message {
 public:
  get_login_key_ack();
  virtual ~get_login_key_ack();

  get_login_key_ack(const get_login_key_ack& from);

  inline get_login_key_ack& operator=(const get_login_key_ack& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const get_login_key_ack& default_instance();

  void Swap(get_login_key_ack* other);

  // implements Message ----------------------------------------------

  get_login_key_ack* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const get_login_key_ack& from);
  void MergeFrom(const get_login_key_ack& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // optional string key = 2;
  inline bool has_key() const;
  inline void clear_key();
  static const int kKeyFieldNumber = 2;
  inline const ::std::string& key() const;
  inline void set_key(const ::std::string& value);
  inline void set_key(const char* value);
  inline void set_key(const char* value, size_t size);
  inline ::std::string* mutable_key();
  inline ::std::string* release_key();
  inline void set_allocated_key(::std::string* key);

  // optional int32 leave_time = 3;
  inline bool has_leave_time() const;
  inline void clear_leave_time();
  static const int kLeaveTimeFieldNumber = 3;
  inline ::google::protobuf::int32 leave_time() const;
  inline void set_leave_time(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.get_login_key_ack)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_key();
  inline void clear_has_key();
  inline void set_has_leave_time();
  inline void clear_has_leave_time();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::std::string* key_;
  ::google::protobuf::int32 leave_time_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static get_login_key_ack* default_instance_;
};
// -------------------------------------------------------------------

class login_gs_req : public ::google::protobuf::Message {
 public:
  login_gs_req();
  virtual ~login_gs_req();

  login_gs_req(const login_gs_req& from);

  inline login_gs_req& operator=(const login_gs_req& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const login_gs_req& default_instance();

  void Swap(login_gs_req* other);

  // implements Message ----------------------------------------------

  login_gs_req* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const login_gs_req& from);
  void MergeFrom(const login_gs_req& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // optional string account = 2;
  inline bool has_account() const;
  inline void clear_account();
  static const int kAccountFieldNumber = 2;
  inline const ::std::string& account() const;
  inline void set_account(const ::std::string& value);
  inline void set_account(const char* value);
  inline void set_account(const char* value, size_t size);
  inline ::std::string* mutable_account();
  inline ::std::string* release_account();
  inline void set_allocated_account(::std::string* account);

  // optional uint32 area_id = 3;
  inline bool has_area_id() const;
  inline void clear_area_id();
  static const int kAreaIdFieldNumber = 3;
  inline ::google::protobuf::uint32 area_id() const;
  inline void set_area_id(::google::protobuf::uint32 value);

  // optional int32 platform_id = 4;
  inline bool has_platform_id() const;
  inline void clear_platform_id();
  static const int kPlatformIdFieldNumber = 4;
  inline ::google::protobuf::int32 platform_id() const;
  inline void set_platform_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.login_gs_req)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_account();
  inline void clear_has_account();
  inline void set_has_area_id();
  inline void clear_has_area_id();
  inline void set_has_platform_id();
  inline void clear_has_platform_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::std::string* account_;
  ::google::protobuf::uint32 area_id_;
  ::google::protobuf::int32 platform_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static login_gs_req* default_instance_;
};
// -------------------------------------------------------------------

class login_gs_ack : public ::google::protobuf::Message {
 public:
  login_gs_ack();
  virtual ~login_gs_ack();

  login_gs_ack(const login_gs_ack& from);

  inline login_gs_ack& operator=(const login_gs_ack& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const login_gs_ack& default_instance();

  void Swap(login_gs_ack* other);

  // implements Message ----------------------------------------------

  login_gs_ack* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const login_gs_ack& from);
  void MergeFrom(const login_gs_ack& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // optional string gate_ip = 2;
  inline bool has_gate_ip() const;
  inline void clear_gate_ip();
  static const int kGateIpFieldNumber = 2;
  inline const ::std::string& gate_ip() const;
  inline void set_gate_ip(const ::std::string& value);
  inline void set_gate_ip(const char* value);
  inline void set_gate_ip(const char* value, size_t size);
  inline ::std::string* mutable_gate_ip();
  inline ::std::string* release_gate_ip();
  inline void set_allocated_gate_ip(::std::string* gate_ip);

  // optional int32 gateport = 3;
  inline bool has_gateport() const;
  inline void clear_gateport();
  static const int kGateportFieldNumber = 3;
  inline ::google::protobuf::int32 gateport() const;
  inline void set_gateport(::google::protobuf::int32 value);

  // optional int32 gate_key = 4;
  inline bool has_gate_key() const;
  inline void clear_gate_key();
  static const int kGateKeyFieldNumber = 4;
  inline ::google::protobuf::int32 gate_key() const;
  inline void set_gate_key(::google::protobuf::int32 value);

  // optional int32 err_no = 5;
  inline bool has_err_no() const;
  inline void clear_err_no();
  static const int kErrNoFieldNumber = 5;
  inline ::google::protobuf::int32 err_no() const;
  inline void set_err_no(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.login_gs_ack)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_gate_ip();
  inline void clear_has_gate_ip();
  inline void set_has_gateport();
  inline void clear_has_gateport();
  inline void set_has_gate_key();
  inline void clear_has_gate_key();
  inline void set_has_err_no();
  inline void clear_has_err_no();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::std::string* gate_ip_;
  ::google::protobuf::int32 gateport_;
  ::google::protobuf::int32 gate_key_;
  ::google::protobuf::int32 err_no_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static login_gs_ack* default_instance_;
};
// -------------------------------------------------------------------

class online_gs_rpt : public ::google::protobuf::Message {
 public:
  online_gs_rpt();
  virtual ~online_gs_rpt();

  online_gs_rpt(const online_gs_rpt& from);

  inline online_gs_rpt& operator=(const online_gs_rpt& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const online_gs_rpt& default_instance();

  void Swap(online_gs_rpt* other);

  // implements Message ----------------------------------------------

  online_gs_rpt* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const online_gs_rpt& from);
  void MergeFrom(const online_gs_rpt& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // optional string gsid = 2;
  inline bool has_gsid() const;
  inline void clear_gsid();
  static const int kGsidFieldNumber = 2;
  inline const ::std::string& gsid() const;
  inline void set_gsid(const ::std::string& value);
  inline void set_gsid(const char* value);
  inline void set_gsid(const char* value, size_t size);
  inline ::std::string* mutable_gsid();
  inline ::std::string* release_gsid();
  inline void set_allocated_gsid(::std::string* gsid);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.online_gs_rpt)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_gsid();
  inline void clear_has_gsid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::std::string* gsid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static online_gs_rpt* default_instance_;
};
// -------------------------------------------------------------------

class switch_gs_lock_req : public ::google::protobuf::Message {
 public:
  switch_gs_lock_req();
  virtual ~switch_gs_lock_req();

  switch_gs_lock_req(const switch_gs_lock_req& from);

  inline switch_gs_lock_req& operator=(const switch_gs_lock_req& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const switch_gs_lock_req& default_instance();

  void Swap(switch_gs_lock_req* other);

  // implements Message ----------------------------------------------

  switch_gs_lock_req* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const switch_gs_lock_req& from);
  void MergeFrom(const switch_gs_lock_req& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // optional string gsid = 2;
  inline bool has_gsid() const;
  inline void clear_gsid();
  static const int kGsidFieldNumber = 2;
  inline const ::std::string& gsid() const;
  inline void set_gsid(const ::std::string& value);
  inline void set_gsid(const char* value);
  inline void set_gsid(const char* value, size_t size);
  inline ::std::string* mutable_gsid();
  inline ::std::string* release_gsid();
  inline void set_allocated_gsid(::std::string* gsid);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.switch_gs_lock_req)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_gsid();
  inline void clear_has_gsid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::std::string* gsid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static switch_gs_lock_req* default_instance_;
};
// -------------------------------------------------------------------

class switch_gs_lock_ack : public ::google::protobuf::Message {
 public:
  switch_gs_lock_ack();
  virtual ~switch_gs_lock_ack();

  switch_gs_lock_ack(const switch_gs_lock_ack& from);

  inline switch_gs_lock_ack& operator=(const switch_gs_lock_ack& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const switch_gs_lock_ack& default_instance();

  void Swap(switch_gs_lock_ack* other);

  // implements Message ----------------------------------------------

  switch_gs_lock_ack* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const switch_gs_lock_ack& from);
  void MergeFrom(const switch_gs_lock_ack& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 playerid = 1;
  inline bool has_playerid() const;
  inline void clear_playerid();
  static const int kPlayeridFieldNumber = 1;
  inline ::google::protobuf::uint64 playerid() const;
  inline void set_playerid(::google::protobuf::uint64 value);

  // optional string gsid = 2;
  inline bool has_gsid() const;
  inline void clear_gsid();
  static const int kGsidFieldNumber = 2;
  inline const ::std::string& gsid() const;
  inline void set_gsid(const ::std::string& value);
  inline void set_gsid(const char* value);
  inline void set_gsid(const char* value, size_t size);
  inline ::std::string* mutable_gsid();
  inline ::std::string* release_gsid();
  inline void set_allocated_gsid(::std::string* gsid);

  // @@protoc_insertion_point(class_scope:protoc.gs_dbs.switch_gs_lock_ack)
 private:
  inline void set_has_playerid();
  inline void clear_has_playerid();
  inline void set_has_gsid();
  inline void clear_has_gsid();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 playerid_;
  ::std::string* gsid_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_AssignDesc_gameserver_5fdbserver_2eproto();
  friend void protobuf_ShutdownFile_gameserver_5fdbserver_2eproto();

  void InitAsDefaultInstance();
  static switch_gs_lock_ack* default_instance_;
};
// ===================================================================

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

// GameServerRpt

// optional string gsid = 1;
inline bool GameServerRpt::has_gsid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GameServerRpt::set_has_gsid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GameServerRpt::clear_has_gsid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GameServerRpt::clear_gsid() {
  if (gsid_ != &::google::protobuf::internal::kEmptyString) {
    gsid_->clear();
  }
  clear_has_gsid();
}
inline const ::std::string& GameServerRpt::gsid() const {
  return *gsid_;
}
inline void GameServerRpt::set_gsid(const ::std::string& value) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(value);
}
inline void GameServerRpt::set_gsid(const char* value) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(value);
}
inline void GameServerRpt::set_gsid(const char* value, size_t size) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GameServerRpt::mutable_gsid() {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  return gsid_;
}
inline ::std::string* GameServerRpt::release_gsid() {
  clear_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = gsid_;
    gsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GameServerRpt::set_allocated_gsid(::std::string* gsid) {
  if (gsid_ != &::google::protobuf::internal::kEmptyString) {
    delete gsid_;
  }
  if (gsid) {
    set_has_gsid();
    gsid_ = gsid;
  } else {
    clear_has_gsid();
    gsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string gsname = 2;
inline bool GameServerRpt::has_gsname() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GameServerRpt::set_has_gsname() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GameServerRpt::clear_has_gsname() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GameServerRpt::clear_gsname() {
  if (gsname_ != &::google::protobuf::internal::kEmptyString) {
    gsname_->clear();
  }
  clear_has_gsname();
}
inline const ::std::string& GameServerRpt::gsname() const {
  return *gsname_;
}
inline void GameServerRpt::set_gsname(const ::std::string& value) {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  gsname_->assign(value);
}
inline void GameServerRpt::set_gsname(const char* value) {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  gsname_->assign(value);
}
inline void GameServerRpt::set_gsname(const char* value, size_t size) {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  gsname_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GameServerRpt::mutable_gsname() {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  return gsname_;
}
inline ::std::string* GameServerRpt::release_gsname() {
  clear_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = gsname_;
    gsname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GameServerRpt::set_allocated_gsname(::std::string* gsname) {
  if (gsname_ != &::google::protobuf::internal::kEmptyString) {
    delete gsname_;
  }
  if (gsname) {
    set_has_gsname();
    gsname_ = gsname;
  } else {
    clear_has_gsname();
    gsname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 max_number = 3;
inline bool GameServerRpt::has_max_number() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GameServerRpt::set_has_max_number() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GameServerRpt::clear_has_max_number() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GameServerRpt::clear_max_number() {
  max_number_ = 0;
  clear_has_max_number();
}
inline ::google::protobuf::int32 GameServerRpt::max_number() const {
  return max_number_;
}
inline void GameServerRpt::set_max_number(::google::protobuf::int32 value) {
  set_has_max_number();
  max_number_ = value;
}

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

// DBServerRpt

// optional string dbid = 1;
inline bool DBServerRpt::has_dbid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DBServerRpt::set_has_dbid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DBServerRpt::clear_has_dbid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DBServerRpt::clear_dbid() {
  if (dbid_ != &::google::protobuf::internal::kEmptyString) {
    dbid_->clear();
  }
  clear_has_dbid();
}
inline const ::std::string& DBServerRpt::dbid() const {
  return *dbid_;
}
inline void DBServerRpt::set_dbid(const ::std::string& value) {
  set_has_dbid();
  if (dbid_ == &::google::protobuf::internal::kEmptyString) {
    dbid_ = new ::std::string;
  }
  dbid_->assign(value);
}
inline void DBServerRpt::set_dbid(const char* value) {
  set_has_dbid();
  if (dbid_ == &::google::protobuf::internal::kEmptyString) {
    dbid_ = new ::std::string;
  }
  dbid_->assign(value);
}
inline void DBServerRpt::set_dbid(const char* value, size_t size) {
  set_has_dbid();
  if (dbid_ == &::google::protobuf::internal::kEmptyString) {
    dbid_ = new ::std::string;
  }
  dbid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DBServerRpt::mutable_dbid() {
  set_has_dbid();
  if (dbid_ == &::google::protobuf::internal::kEmptyString) {
    dbid_ = new ::std::string;
  }
  return dbid_;
}
inline ::std::string* DBServerRpt::release_dbid() {
  clear_has_dbid();
  if (dbid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = dbid_;
    dbid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void DBServerRpt::set_allocated_dbid(::std::string* dbid) {
  if (dbid_ != &::google::protobuf::internal::kEmptyString) {
    delete dbid_;
  }
  if (dbid) {
    set_has_dbid();
    dbid_ = dbid;
  } else {
    clear_has_dbid();
    dbid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string dbname = 2;
inline bool DBServerRpt::has_dbname() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DBServerRpt::set_has_dbname() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DBServerRpt::clear_has_dbname() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DBServerRpt::clear_dbname() {
  if (dbname_ != &::google::protobuf::internal::kEmptyString) {
    dbname_->clear();
  }
  clear_has_dbname();
}
inline const ::std::string& DBServerRpt::dbname() const {
  return *dbname_;
}
inline void DBServerRpt::set_dbname(const ::std::string& value) {
  set_has_dbname();
  if (dbname_ == &::google::protobuf::internal::kEmptyString) {
    dbname_ = new ::std::string;
  }
  dbname_->assign(value);
}
inline void DBServerRpt::set_dbname(const char* value) {
  set_has_dbname();
  if (dbname_ == &::google::protobuf::internal::kEmptyString) {
    dbname_ = new ::std::string;
  }
  dbname_->assign(value);
}
inline void DBServerRpt::set_dbname(const char* value, size_t size) {
  set_has_dbname();
  if (dbname_ == &::google::protobuf::internal::kEmptyString) {
    dbname_ = new ::std::string;
  }
  dbname_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DBServerRpt::mutable_dbname() {
  set_has_dbname();
  if (dbname_ == &::google::protobuf::internal::kEmptyString) {
    dbname_ = new ::std::string;
  }
  return dbname_;
}
inline ::std::string* DBServerRpt::release_dbname() {
  clear_has_dbname();
  if (dbname_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = dbname_;
    dbname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void DBServerRpt::set_allocated_dbname(::std::string* dbname) {
  if (dbname_ != &::google::protobuf::internal::kEmptyString) {
    delete dbname_;
  }
  if (dbname) {
    set_has_dbname();
    dbname_ = dbname;
  } else {
    clear_has_dbname();
    dbname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// KickOutRpt

// optional uint64 playerid = 1;
inline bool KickOutRpt::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void KickOutRpt::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void KickOutRpt::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void KickOutRpt::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 KickOutRpt::playerid() const {
  return playerid_;
}
inline void KickOutRpt::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// KickOutAck

// optional uint64 playerid = 1;
inline bool KickOutAck::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void KickOutAck::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void KickOutAck::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void KickOutAck::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 KickOutAck::playerid() const {
  return playerid_;
}
inline void KickOutAck::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// optional int32 error_no = 2;
inline bool KickOutAck::has_error_no() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void KickOutAck::set_has_error_no() {
  _has_bits_[0] |= 0x00000002u;
}
inline void KickOutAck::clear_has_error_no() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void KickOutAck::clear_error_no() {
  error_no_ = 0;
  clear_has_error_no();
}
inline ::google::protobuf::int32 KickOutAck::error_no() const {
  return error_no_;
}
inline void KickOutAck::set_error_no(::google::protobuf::int32 value) {
  set_has_error_no();
  error_no_ = value;
}

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

// RandCheckReq

// optional bytes key = 1;
inline bool RandCheckReq::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RandCheckReq::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RandCheckReq::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RandCheckReq::clear_key() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    key_->clear();
  }
  clear_has_key();
}
inline const ::std::string& RandCheckReq::key() const {
  return *key_;
}
inline void RandCheckReq::set_key(const ::std::string& value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void RandCheckReq::set_key(const char* value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void RandCheckReq::set_key(const void* value, size_t size) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RandCheckReq::mutable_key() {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  return key_;
}
inline ::std::string* RandCheckReq::release_key() {
  clear_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = key_;
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RandCheckReq::set_allocated_key(::std::string* key) {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (key) {
    set_has_key();
    key_ = key;
  } else {
    clear_has_key();
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// RandCheckAck

// optional bytes rand_text = 1;
inline bool RandCheckAck::has_rand_text() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RandCheckAck::set_has_rand_text() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RandCheckAck::clear_has_rand_text() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RandCheckAck::clear_rand_text() {
  if (rand_text_ != &::google::protobuf::internal::kEmptyString) {
    rand_text_->clear();
  }
  clear_has_rand_text();
}
inline const ::std::string& RandCheckAck::rand_text() const {
  return *rand_text_;
}
inline void RandCheckAck::set_rand_text(const ::std::string& value) {
  set_has_rand_text();
  if (rand_text_ == &::google::protobuf::internal::kEmptyString) {
    rand_text_ = new ::std::string;
  }
  rand_text_->assign(value);
}
inline void RandCheckAck::set_rand_text(const char* value) {
  set_has_rand_text();
  if (rand_text_ == &::google::protobuf::internal::kEmptyString) {
    rand_text_ = new ::std::string;
  }
  rand_text_->assign(value);
}
inline void RandCheckAck::set_rand_text(const void* value, size_t size) {
  set_has_rand_text();
  if (rand_text_ == &::google::protobuf::internal::kEmptyString) {
    rand_text_ = new ::std::string;
  }
  rand_text_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RandCheckAck::mutable_rand_text() {
  set_has_rand_text();
  if (rand_text_ == &::google::protobuf::internal::kEmptyString) {
    rand_text_ = new ::std::string;
  }
  return rand_text_;
}
inline ::std::string* RandCheckAck::release_rand_text() {
  clear_has_rand_text();
  if (rand_text_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = rand_text_;
    rand_text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RandCheckAck::set_allocated_rand_text(::std::string* rand_text) {
  if (rand_text_ != &::google::protobuf::internal::kEmptyString) {
    delete rand_text_;
  }
  if (rand_text) {
    set_has_rand_text();
    rand_text_ = rand_text;
  } else {
    clear_has_rand_text();
    rand_text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// HeartPingReq

// optional int32 opt = 1;
inline bool HeartPingReq::has_opt() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HeartPingReq::set_has_opt() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HeartPingReq::clear_has_opt() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HeartPingReq::clear_opt() {
  opt_ = 0;
  clear_has_opt();
}
inline ::google::protobuf::int32 HeartPingReq::opt() const {
  return opt_;
}
inline void HeartPingReq::set_opt(::google::protobuf::int32 value) {
  set_has_opt();
  opt_ = value;
}

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

// HeartPingAck

// optional int32 opt = 1;
inline bool HeartPingAck::has_opt() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HeartPingAck::set_has_opt() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HeartPingAck::clear_has_opt() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HeartPingAck::clear_opt() {
  opt_ = 0;
  clear_has_opt();
}
inline ::google::protobuf::int32 HeartPingAck::opt() const {
  return opt_;
}
inline void HeartPingAck::set_opt(::google::protobuf::int32 value) {
  set_has_opt();
  opt_ = value;
}

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

// GetIDReq

// optional uint32 kind = 1;
inline bool GetIDReq::has_kind() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetIDReq::set_has_kind() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetIDReq::clear_has_kind() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetIDReq::clear_kind() {
  kind_ = 0u;
  clear_has_kind();
}
inline ::google::protobuf::uint32 GetIDReq::kind() const {
  return kind_;
}
inline void GetIDReq::set_kind(::google::protobuf::uint32 value) {
  set_has_kind();
  kind_ = value;
}

// optional uint32 number = 2;
inline bool GetIDReq::has_number() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetIDReq::set_has_number() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetIDReq::clear_has_number() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetIDReq::clear_number() {
  number_ = 0u;
  clear_has_number();
}
inline ::google::protobuf::uint32 GetIDReq::number() const {
  return number_;
}
inline void GetIDReq::set_number(::google::protobuf::uint32 value) {
  set_has_number();
  number_ = value;
}

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

// GetIDAck

// optional uint32 kind = 1;
inline bool GetIDAck::has_kind() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetIDAck::set_has_kind() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetIDAck::clear_has_kind() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetIDAck::clear_kind() {
  kind_ = 0u;
  clear_has_kind();
}
inline ::google::protobuf::uint32 GetIDAck::kind() const {
  return kind_;
}
inline void GetIDAck::set_kind(::google::protobuf::uint32 value) {
  set_has_kind();
  kind_ = value;
}

// optional uint32 number = 2;
inline bool GetIDAck::has_number() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetIDAck::set_has_number() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetIDAck::clear_has_number() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetIDAck::clear_number() {
  number_ = 0u;
  clear_has_number();
}
inline ::google::protobuf::uint32 GetIDAck::number() const {
  return number_;
}
inline void GetIDAck::set_number(::google::protobuf::uint32 value) {
  set_has_number();
  number_ = value;
}

// optional uint64 begin_id = 3;
inline bool GetIDAck::has_begin_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetIDAck::set_has_begin_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetIDAck::clear_has_begin_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetIDAck::clear_begin_id() {
  begin_id_ = GOOGLE_ULONGLONG(0);
  clear_has_begin_id();
}
inline ::google::protobuf::uint64 GetIDAck::begin_id() const {
  return begin_id_;
}
inline void GetIDAck::set_begin_id(::google::protobuf::uint64 value) {
  set_has_begin_id();
  begin_id_ = value;
}

// optional uint64 end_id = 4;
inline bool GetIDAck::has_end_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GetIDAck::set_has_end_id() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GetIDAck::clear_has_end_id() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GetIDAck::clear_end_id() {
  end_id_ = GOOGLE_ULONGLONG(0);
  clear_has_end_id();
}
inline ::google::protobuf::uint64 GetIDAck::end_id() const {
  return end_id_;
}
inline void GetIDAck::set_end_id(::google::protobuf::uint64 value) {
  set_has_end_id();
  end_id_ = value;
}

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

// GMListRpt_gm

// optional int32 gm_level = 2;
inline bool GMListRpt_gm::has_gm_level() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GMListRpt_gm::set_has_gm_level() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GMListRpt_gm::clear_has_gm_level() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GMListRpt_gm::clear_gm_level() {
  gm_level_ = 0;
  clear_has_gm_level();
}
inline ::google::protobuf::int32 GMListRpt_gm::gm_level() const {
  return gm_level_;
}
inline void GMListRpt_gm::set_gm_level(::google::protobuf::int32 value) {
  set_has_gm_level();
  gm_level_ = value;
}

// optional string account = 3;
inline bool GMListRpt_gm::has_account() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GMListRpt_gm::set_has_account() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GMListRpt_gm::clear_has_account() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GMListRpt_gm::clear_account() {
  if (account_ != &::google::protobuf::internal::kEmptyString) {
    account_->clear();
  }
  clear_has_account();
}
inline const ::std::string& GMListRpt_gm::account() const {
  return *account_;
}
inline void GMListRpt_gm::set_account(const ::std::string& value) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(value);
}
inline void GMListRpt_gm::set_account(const char* value) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(value);
}
inline void GMListRpt_gm::set_account(const char* value, size_t size) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMListRpt_gm::mutable_account() {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  return account_;
}
inline ::std::string* GMListRpt_gm::release_account() {
  clear_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = account_;
    account_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMListRpt_gm::set_allocated_account(::std::string* account) {
  if (account_ != &::google::protobuf::internal::kEmptyString) {
    delete account_;
  }
  if (account) {
    set_has_account();
    account_ = account;
  } else {
    clear_has_account();
    account_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string password = 4;
inline bool GMListRpt_gm::has_password() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GMListRpt_gm::set_has_password() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GMListRpt_gm::clear_has_password() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GMListRpt_gm::clear_password() {
  if (password_ != &::google::protobuf::internal::kEmptyString) {
    password_->clear();
  }
  clear_has_password();
}
inline const ::std::string& GMListRpt_gm::password() const {
  return *password_;
}
inline void GMListRpt_gm::set_password(const ::std::string& value) {
  set_has_password();
  if (password_ == &::google::protobuf::internal::kEmptyString) {
    password_ = new ::std::string;
  }
  password_->assign(value);
}
inline void GMListRpt_gm::set_password(const char* value) {
  set_has_password();
  if (password_ == &::google::protobuf::internal::kEmptyString) {
    password_ = new ::std::string;
  }
  password_->assign(value);
}
inline void GMListRpt_gm::set_password(const char* value, size_t size) {
  set_has_password();
  if (password_ == &::google::protobuf::internal::kEmptyString) {
    password_ = new ::std::string;
  }
  password_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMListRpt_gm::mutable_password() {
  set_has_password();
  if (password_ == &::google::protobuf::internal::kEmptyString) {
    password_ = new ::std::string;
  }
  return password_;
}
inline ::std::string* GMListRpt_gm::release_password() {
  clear_has_password();
  if (password_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = password_;
    password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMListRpt_gm::set_allocated_password(::std::string* password) {
  if (password_ != &::google::protobuf::internal::kEmptyString) {
    delete password_;
  }
  if (password) {
    set_has_password();
    password_ = password;
  } else {
    clear_has_password();
    password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// GMListRpt

// repeated .protoc.gs_dbs.GMListRpt.gm table = 1;
inline int GMListRpt::table_size() const {
  return table_.size();
}
inline void GMListRpt::clear_table() {
  table_.Clear();
}
inline const ::protoc::gs_dbs::GMListRpt_gm& GMListRpt::table(int index) const {
  return table_.Get(index);
}
inline ::protoc::gs_dbs::GMListRpt_gm* GMListRpt::mutable_table(int index) {
  return table_.Mutable(index);
}
inline ::protoc::gs_dbs::GMListRpt_gm* GMListRpt::add_table() {
  return table_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GMListRpt_gm >&
GMListRpt::table() const {
  return table_;
}
inline ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GMListRpt_gm >*
GMListRpt::mutable_table() {
  return &table_;
}

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

// CheckNewNameReq

// required uint64 playerid = 1;
inline bool CheckNewNameReq::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CheckNewNameReq::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CheckNewNameReq::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CheckNewNameReq::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 CheckNewNameReq::playerid() const {
  return playerid_;
}
inline void CheckNewNameReq::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// required string newname = 2;
inline bool CheckNewNameReq::has_newname() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CheckNewNameReq::set_has_newname() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CheckNewNameReq::clear_has_newname() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CheckNewNameReq::clear_newname() {
  if (newname_ != &::google::protobuf::internal::kEmptyString) {
    newname_->clear();
  }
  clear_has_newname();
}
inline const ::std::string& CheckNewNameReq::newname() const {
  return *newname_;
}
inline void CheckNewNameReq::set_newname(const ::std::string& value) {
  set_has_newname();
  if (newname_ == &::google::protobuf::internal::kEmptyString) {
    newname_ = new ::std::string;
  }
  newname_->assign(value);
}
inline void CheckNewNameReq::set_newname(const char* value) {
  set_has_newname();
  if (newname_ == &::google::protobuf::internal::kEmptyString) {
    newname_ = new ::std::string;
  }
  newname_->assign(value);
}
inline void CheckNewNameReq::set_newname(const char* value, size_t size) {
  set_has_newname();
  if (newname_ == &::google::protobuf::internal::kEmptyString) {
    newname_ = new ::std::string;
  }
  newname_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CheckNewNameReq::mutable_newname() {
  set_has_newname();
  if (newname_ == &::google::protobuf::internal::kEmptyString) {
    newname_ = new ::std::string;
  }
  return newname_;
}
inline ::std::string* CheckNewNameReq::release_newname() {
  clear_has_newname();
  if (newname_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = newname_;
    newname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void CheckNewNameReq::set_allocated_newname(::std::string* newname) {
  if (newname_ != &::google::protobuf::internal::kEmptyString) {
    delete newname_;
  }
  if (newname) {
    set_has_newname();
    newname_ = newname;
  } else {
    clear_has_newname();
    newname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 head_pic_id = 3;
inline bool CheckNewNameReq::has_head_pic_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CheckNewNameReq::set_has_head_pic_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CheckNewNameReq::clear_has_head_pic_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CheckNewNameReq::clear_head_pic_id() {
  head_pic_id_ = 0u;
  clear_has_head_pic_id();
}
inline ::google::protobuf::uint32 CheckNewNameReq::head_pic_id() const {
  return head_pic_id_;
}
inline void CheckNewNameReq::set_head_pic_id(::google::protobuf::uint32 value) {
  set_has_head_pic_id();
  head_pic_id_ = value;
}

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

// CheckNewNameAck

// required uint64 playerid = 1;
inline bool CheckNewNameAck::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CheckNewNameAck::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CheckNewNameAck::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CheckNewNameAck::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 CheckNewNameAck::playerid() const {
  return playerid_;
}
inline void CheckNewNameAck::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// required string newname = 2;
inline bool CheckNewNameAck::has_newname() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CheckNewNameAck::set_has_newname() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CheckNewNameAck::clear_has_newname() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CheckNewNameAck::clear_newname() {
  if (newname_ != &::google::protobuf::internal::kEmptyString) {
    newname_->clear();
  }
  clear_has_newname();
}
inline const ::std::string& CheckNewNameAck::newname() const {
  return *newname_;
}
inline void CheckNewNameAck::set_newname(const ::std::string& value) {
  set_has_newname();
  if (newname_ == &::google::protobuf::internal::kEmptyString) {
    newname_ = new ::std::string;
  }
  newname_->assign(value);
}
inline void CheckNewNameAck::set_newname(const char* value) {
  set_has_newname();
  if (newname_ == &::google::protobuf::internal::kEmptyString) {
    newname_ = new ::std::string;
  }
  newname_->assign(value);
}
inline void CheckNewNameAck::set_newname(const char* value, size_t size) {
  set_has_newname();
  if (newname_ == &::google::protobuf::internal::kEmptyString) {
    newname_ = new ::std::string;
  }
  newname_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CheckNewNameAck::mutable_newname() {
  set_has_newname();
  if (newname_ == &::google::protobuf::internal::kEmptyString) {
    newname_ = new ::std::string;
  }
  return newname_;
}
inline ::std::string* CheckNewNameAck::release_newname() {
  clear_has_newname();
  if (newname_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = newname_;
    newname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void CheckNewNameAck::set_allocated_newname(::std::string* newname) {
  if (newname_ != &::google::protobuf::internal::kEmptyString) {
    delete newname_;
  }
  if (newname) {
    set_has_newname();
    newname_ = newname;
  } else {
    clear_has_newname();
    newname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 head_pic_id = 3;
inline bool CheckNewNameAck::has_head_pic_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CheckNewNameAck::set_has_head_pic_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CheckNewNameAck::clear_has_head_pic_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CheckNewNameAck::clear_head_pic_id() {
  head_pic_id_ = 0u;
  clear_has_head_pic_id();
}
inline ::google::protobuf::uint32 CheckNewNameAck::head_pic_id() const {
  return head_pic_id_;
}
inline void CheckNewNameAck::set_head_pic_id(::google::protobuf::uint32 value) {
  set_has_head_pic_id();
  head_pic_id_ = value;
}

// required int32 error_no = 4;
inline bool CheckNewNameAck::has_error_no() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CheckNewNameAck::set_has_error_no() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CheckNewNameAck::clear_has_error_no() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CheckNewNameAck::clear_error_no() {
  error_no_ = 0;
  clear_has_error_no();
}
inline ::google::protobuf::int32 CheckNewNameAck::error_no() const {
  return error_no_;
}
inline void CheckNewNameAck::set_error_no(::google::protobuf::int32 value) {
  set_has_error_no();
  error_no_ = value;
}

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

// GSState

// optional string gsid = 1;
inline bool GSState::has_gsid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GSState::set_has_gsid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GSState::clear_has_gsid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GSState::clear_gsid() {
  if (gsid_ != &::google::protobuf::internal::kEmptyString) {
    gsid_->clear();
  }
  clear_has_gsid();
}
inline const ::std::string& GSState::gsid() const {
  return *gsid_;
}
inline void GSState::set_gsid(const ::std::string& value) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(value);
}
inline void GSState::set_gsid(const char* value) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(value);
}
inline void GSState::set_gsid(const char* value, size_t size) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GSState::mutable_gsid() {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  return gsid_;
}
inline ::std::string* GSState::release_gsid() {
  clear_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = gsid_;
    gsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GSState::set_allocated_gsid(::std::string* gsid) {
  if (gsid_ != &::google::protobuf::internal::kEmptyString) {
    delete gsid_;
  }
  if (gsid) {
    set_has_gsid();
    gsid_ = gsid;
  } else {
    clear_has_gsid();
    gsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string gsname = 2;
inline bool GSState::has_gsname() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GSState::set_has_gsname() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GSState::clear_has_gsname() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GSState::clear_gsname() {
  if (gsname_ != &::google::protobuf::internal::kEmptyString) {
    gsname_->clear();
  }
  clear_has_gsname();
}
inline const ::std::string& GSState::gsname() const {
  return *gsname_;
}
inline void GSState::set_gsname(const ::std::string& value) {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  gsname_->assign(value);
}
inline void GSState::set_gsname(const char* value) {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  gsname_->assign(value);
}
inline void GSState::set_gsname(const char* value, size_t size) {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  gsname_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GSState::mutable_gsname() {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  return gsname_;
}
inline ::std::string* GSState::release_gsname() {
  clear_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = gsname_;
    gsname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GSState::set_allocated_gsname(::std::string* gsname) {
  if (gsname_ != &::google::protobuf::internal::kEmptyString) {
    delete gsname_;
  }
  if (gsname) {
    set_has_gsname();
    gsname_ = gsname;
  } else {
    clear_has_gsname();
    gsname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 state = 3;
inline bool GSState::has_state() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GSState::set_has_state() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GSState::clear_has_state() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GSState::clear_state() {
  state_ = 0;
  clear_has_state();
}
inline ::google::protobuf::int32 GSState::state() const {
  return state_;
}
inline void GSState::set_state(::google::protobuf::int32 value) {
  set_has_state();
  state_ = value;
}

// optional int32 cur_online_number = 4;
inline bool GSState::has_cur_online_number() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GSState::set_has_cur_online_number() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GSState::clear_has_cur_online_number() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GSState::clear_cur_online_number() {
  cur_online_number_ = 0;
  clear_has_cur_online_number();
}
inline ::google::protobuf::int32 GSState::cur_online_number() const {
  return cur_online_number_;
}
inline void GSState::set_cur_online_number(::google::protobuf::int32 value) {
  set_has_cur_online_number();
  cur_online_number_ = value;
}

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

// GameServerStateNtf

// optional .protoc.gs_dbs.GSState gs = 1;
inline bool GameServerStateNtf::has_gs() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GameServerStateNtf::set_has_gs() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GameServerStateNtf::clear_has_gs() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GameServerStateNtf::clear_gs() {
  if (gs_ != NULL) gs_->::protoc::gs_dbs::GSState::Clear();
  clear_has_gs();
}
inline const ::protoc::gs_dbs::GSState& GameServerStateNtf::gs() const {
  return gs_ != NULL ? *gs_ : *default_instance_->gs_;
}
inline ::protoc::gs_dbs::GSState* GameServerStateNtf::mutable_gs() {
  set_has_gs();
  if (gs_ == NULL) gs_ = new ::protoc::gs_dbs::GSState;
  return gs_;
}
inline ::protoc::gs_dbs::GSState* GameServerStateNtf::release_gs() {
  clear_has_gs();
  ::protoc::gs_dbs::GSState* temp = gs_;
  gs_ = NULL;
  return temp;
}
inline void GameServerStateNtf::set_allocated_gs(::protoc::gs_dbs::GSState* gs) {
  delete gs_;
  gs_ = gs;
  if (gs) {
    set_has_gs();
  } else {
    clear_has_gs();
  }
}

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

// AllGameServerStateRpt

// repeated .protoc.gs_dbs.GSState gs = 1;
inline int AllGameServerStateRpt::gs_size() const {
  return gs_.size();
}
inline void AllGameServerStateRpt::clear_gs() {
  gs_.Clear();
}
inline const ::protoc::gs_dbs::GSState& AllGameServerStateRpt::gs(int index) const {
  return gs_.Get(index);
}
inline ::protoc::gs_dbs::GSState* AllGameServerStateRpt::mutable_gs(int index) {
  return gs_.Mutable(index);
}
inline ::protoc::gs_dbs::GSState* AllGameServerStateRpt::add_gs() {
  return gs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GSState >&
AllGameServerStateRpt::gs() const {
  return gs_;
}
inline ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GSState >*
AllGameServerStateRpt::mutable_gs() {
  return &gs_;
}

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

// GMMessageNtf

// optional uint64 playerid = 1;
inline bool GMMessageNtf::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GMMessageNtf::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GMMessageNtf::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GMMessageNtf::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 GMMessageNtf::playerid() const {
  return playerid_;
}
inline void GMMessageNtf::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// optional string account = 2;
inline bool GMMessageNtf::has_account() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GMMessageNtf::set_has_account() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GMMessageNtf::clear_has_account() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GMMessageNtf::clear_account() {
  if (account_ != &::google::protobuf::internal::kEmptyString) {
    account_->clear();
  }
  clear_has_account();
}
inline const ::std::string& GMMessageNtf::account() const {
  return *account_;
}
inline void GMMessageNtf::set_account(const ::std::string& value) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(value);
}
inline void GMMessageNtf::set_account(const char* value) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(value);
}
inline void GMMessageNtf::set_account(const char* value, size_t size) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageNtf::mutable_account() {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  return account_;
}
inline ::std::string* GMMessageNtf::release_account() {
  clear_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = account_;
    account_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageNtf::set_allocated_account(::std::string* account) {
  if (account_ != &::google::protobuf::internal::kEmptyString) {
    delete account_;
  }
  if (account) {
    set_has_account();
    account_ = account;
  } else {
    clear_has_account();
    account_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string playername = 3;
inline bool GMMessageNtf::has_playername() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GMMessageNtf::set_has_playername() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GMMessageNtf::clear_has_playername() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GMMessageNtf::clear_playername() {
  if (playername_ != &::google::protobuf::internal::kEmptyString) {
    playername_->clear();
  }
  clear_has_playername();
}
inline const ::std::string& GMMessageNtf::playername() const {
  return *playername_;
}
inline void GMMessageNtf::set_playername(const ::std::string& value) {
  set_has_playername();
  if (playername_ == &::google::protobuf::internal::kEmptyString) {
    playername_ = new ::std::string;
  }
  playername_->assign(value);
}
inline void GMMessageNtf::set_playername(const char* value) {
  set_has_playername();
  if (playername_ == &::google::protobuf::internal::kEmptyString) {
    playername_ = new ::std::string;
  }
  playername_->assign(value);
}
inline void GMMessageNtf::set_playername(const char* value, size_t size) {
  set_has_playername();
  if (playername_ == &::google::protobuf::internal::kEmptyString) {
    playername_ = new ::std::string;
  }
  playername_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageNtf::mutable_playername() {
  set_has_playername();
  if (playername_ == &::google::protobuf::internal::kEmptyString) {
    playername_ = new ::std::string;
  }
  return playername_;
}
inline ::std::string* GMMessageNtf::release_playername() {
  clear_has_playername();
  if (playername_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = playername_;
    playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageNtf::set_allocated_playername(::std::string* playername) {
  if (playername_ != &::google::protobuf::internal::kEmptyString) {
    delete playername_;
  }
  if (playername) {
    set_has_playername();
    playername_ = playername;
  } else {
    clear_has_playername();
    playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string ip = 4;
inline bool GMMessageNtf::has_ip() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GMMessageNtf::set_has_ip() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GMMessageNtf::clear_has_ip() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GMMessageNtf::clear_ip() {
  if (ip_ != &::google::protobuf::internal::kEmptyString) {
    ip_->clear();
  }
  clear_has_ip();
}
inline const ::std::string& GMMessageNtf::ip() const {
  return *ip_;
}
inline void GMMessageNtf::set_ip(const ::std::string& value) {
  set_has_ip();
  if (ip_ == &::google::protobuf::internal::kEmptyString) {
    ip_ = new ::std::string;
  }
  ip_->assign(value);
}
inline void GMMessageNtf::set_ip(const char* value) {
  set_has_ip();
  if (ip_ == &::google::protobuf::internal::kEmptyString) {
    ip_ = new ::std::string;
  }
  ip_->assign(value);
}
inline void GMMessageNtf::set_ip(const char* value, size_t size) {
  set_has_ip();
  if (ip_ == &::google::protobuf::internal::kEmptyString) {
    ip_ = new ::std::string;
  }
  ip_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageNtf::mutable_ip() {
  set_has_ip();
  if (ip_ == &::google::protobuf::internal::kEmptyString) {
    ip_ = new ::std::string;
  }
  return ip_;
}
inline ::std::string* GMMessageNtf::release_ip() {
  clear_has_ip();
  if (ip_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = ip_;
    ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageNtf::set_allocated_ip(::std::string* ip) {
  if (ip_ != &::google::protobuf::internal::kEmptyString) {
    delete ip_;
  }
  if (ip) {
    set_has_ip();
    ip_ = ip;
  } else {
    clear_has_ip();
    ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string src_gs_id = 5;
inline bool GMMessageNtf::has_src_gs_id() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void GMMessageNtf::set_has_src_gs_id() {
  _has_bits_[0] |= 0x00000010u;
}
inline void GMMessageNtf::clear_has_src_gs_id() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void GMMessageNtf::clear_src_gs_id() {
  if (src_gs_id_ != &::google::protobuf::internal::kEmptyString) {
    src_gs_id_->clear();
  }
  clear_has_src_gs_id();
}
inline const ::std::string& GMMessageNtf::src_gs_id() const {
  return *src_gs_id_;
}
inline void GMMessageNtf::set_src_gs_id(const ::std::string& value) {
  set_has_src_gs_id();
  if (src_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    src_gs_id_ = new ::std::string;
  }
  src_gs_id_->assign(value);
}
inline void GMMessageNtf::set_src_gs_id(const char* value) {
  set_has_src_gs_id();
  if (src_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    src_gs_id_ = new ::std::string;
  }
  src_gs_id_->assign(value);
}
inline void GMMessageNtf::set_src_gs_id(const char* value, size_t size) {
  set_has_src_gs_id();
  if (src_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    src_gs_id_ = new ::std::string;
  }
  src_gs_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageNtf::mutable_src_gs_id() {
  set_has_src_gs_id();
  if (src_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    src_gs_id_ = new ::std::string;
  }
  return src_gs_id_;
}
inline ::std::string* GMMessageNtf::release_src_gs_id() {
  clear_has_src_gs_id();
  if (src_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = src_gs_id_;
    src_gs_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageNtf::set_allocated_src_gs_id(::std::string* src_gs_id) {
  if (src_gs_id_ != &::google::protobuf::internal::kEmptyString) {
    delete src_gs_id_;
  }
  if (src_gs_id) {
    set_has_src_gs_id();
    src_gs_id_ = src_gs_id;
  } else {
    clear_has_src_gs_id();
    src_gs_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string cmd = 6;
inline bool GMMessageNtf::has_cmd() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void GMMessageNtf::set_has_cmd() {
  _has_bits_[0] |= 0x00000020u;
}
inline void GMMessageNtf::clear_has_cmd() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void GMMessageNtf::clear_cmd() {
  if (cmd_ != &::google::protobuf::internal::kEmptyString) {
    cmd_->clear();
  }
  clear_has_cmd();
}
inline const ::std::string& GMMessageNtf::cmd() const {
  return *cmd_;
}
inline void GMMessageNtf::set_cmd(const ::std::string& value) {
  set_has_cmd();
  if (cmd_ == &::google::protobuf::internal::kEmptyString) {
    cmd_ = new ::std::string;
  }
  cmd_->assign(value);
}
inline void GMMessageNtf::set_cmd(const char* value) {
  set_has_cmd();
  if (cmd_ == &::google::protobuf::internal::kEmptyString) {
    cmd_ = new ::std::string;
  }
  cmd_->assign(value);
}
inline void GMMessageNtf::set_cmd(const char* value, size_t size) {
  set_has_cmd();
  if (cmd_ == &::google::protobuf::internal::kEmptyString) {
    cmd_ = new ::std::string;
  }
  cmd_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageNtf::mutable_cmd() {
  set_has_cmd();
  if (cmd_ == &::google::protobuf::internal::kEmptyString) {
    cmd_ = new ::std::string;
  }
  return cmd_;
}
inline ::std::string* GMMessageNtf::release_cmd() {
  clear_has_cmd();
  if (cmd_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = cmd_;
    cmd_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageNtf::set_allocated_cmd(::std::string* cmd) {
  if (cmd_ != &::google::protobuf::internal::kEmptyString) {
    delete cmd_;
  }
  if (cmd) {
    set_has_cmd();
    cmd_ = cmd;
  } else {
    clear_has_cmd();
    cmd_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// GMMessageExecuteAck

// optional uint64 playerid = 1;
inline bool GMMessageExecuteAck::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GMMessageExecuteAck::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GMMessageExecuteAck::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GMMessageExecuteAck::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 GMMessageExecuteAck::playerid() const {
  return playerid_;
}
inline void GMMessageExecuteAck::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// optional string account = 2;
inline bool GMMessageExecuteAck::has_account() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GMMessageExecuteAck::set_has_account() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GMMessageExecuteAck::clear_has_account() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GMMessageExecuteAck::clear_account() {
  if (account_ != &::google::protobuf::internal::kEmptyString) {
    account_->clear();
  }
  clear_has_account();
}
inline const ::std::string& GMMessageExecuteAck::account() const {
  return *account_;
}
inline void GMMessageExecuteAck::set_account(const ::std::string& value) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(value);
}
inline void GMMessageExecuteAck::set_account(const char* value) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(value);
}
inline void GMMessageExecuteAck::set_account(const char* value, size_t size) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageExecuteAck::mutable_account() {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  return account_;
}
inline ::std::string* GMMessageExecuteAck::release_account() {
  clear_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = account_;
    account_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageExecuteAck::set_allocated_account(::std::string* account) {
  if (account_ != &::google::protobuf::internal::kEmptyString) {
    delete account_;
  }
  if (account) {
    set_has_account();
    account_ = account;
  } else {
    clear_has_account();
    account_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string playername = 3;
inline bool GMMessageExecuteAck::has_playername() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GMMessageExecuteAck::set_has_playername() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GMMessageExecuteAck::clear_has_playername() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GMMessageExecuteAck::clear_playername() {
  if (playername_ != &::google::protobuf::internal::kEmptyString) {
    playername_->clear();
  }
  clear_has_playername();
}
inline const ::std::string& GMMessageExecuteAck::playername() const {
  return *playername_;
}
inline void GMMessageExecuteAck::set_playername(const ::std::string& value) {
  set_has_playername();
  if (playername_ == &::google::protobuf::internal::kEmptyString) {
    playername_ = new ::std::string;
  }
  playername_->assign(value);
}
inline void GMMessageExecuteAck::set_playername(const char* value) {
  set_has_playername();
  if (playername_ == &::google::protobuf::internal::kEmptyString) {
    playername_ = new ::std::string;
  }
  playername_->assign(value);
}
inline void GMMessageExecuteAck::set_playername(const char* value, size_t size) {
  set_has_playername();
  if (playername_ == &::google::protobuf::internal::kEmptyString) {
    playername_ = new ::std::string;
  }
  playername_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageExecuteAck::mutable_playername() {
  set_has_playername();
  if (playername_ == &::google::protobuf::internal::kEmptyString) {
    playername_ = new ::std::string;
  }
  return playername_;
}
inline ::std::string* GMMessageExecuteAck::release_playername() {
  clear_has_playername();
  if (playername_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = playername_;
    playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageExecuteAck::set_allocated_playername(::std::string* playername) {
  if (playername_ != &::google::protobuf::internal::kEmptyString) {
    delete playername_;
  }
  if (playername) {
    set_has_playername();
    playername_ = playername;
  } else {
    clear_has_playername();
    playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string cmd = 4;
inline bool GMMessageExecuteAck::has_cmd() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GMMessageExecuteAck::set_has_cmd() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GMMessageExecuteAck::clear_has_cmd() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GMMessageExecuteAck::clear_cmd() {
  if (cmd_ != &::google::protobuf::internal::kEmptyString) {
    cmd_->clear();
  }
  clear_has_cmd();
}
inline const ::std::string& GMMessageExecuteAck::cmd() const {
  return *cmd_;
}
inline void GMMessageExecuteAck::set_cmd(const ::std::string& value) {
  set_has_cmd();
  if (cmd_ == &::google::protobuf::internal::kEmptyString) {
    cmd_ = new ::std::string;
  }
  cmd_->assign(value);
}
inline void GMMessageExecuteAck::set_cmd(const char* value) {
  set_has_cmd();
  if (cmd_ == &::google::protobuf::internal::kEmptyString) {
    cmd_ = new ::std::string;
  }
  cmd_->assign(value);
}
inline void GMMessageExecuteAck::set_cmd(const char* value, size_t size) {
  set_has_cmd();
  if (cmd_ == &::google::protobuf::internal::kEmptyString) {
    cmd_ = new ::std::string;
  }
  cmd_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageExecuteAck::mutable_cmd() {
  set_has_cmd();
  if (cmd_ == &::google::protobuf::internal::kEmptyString) {
    cmd_ = new ::std::string;
  }
  return cmd_;
}
inline ::std::string* GMMessageExecuteAck::release_cmd() {
  clear_has_cmd();
  if (cmd_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = cmd_;
    cmd_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageExecuteAck::set_allocated_cmd(::std::string* cmd) {
  if (cmd_ != &::google::protobuf::internal::kEmptyString) {
    delete cmd_;
  }
  if (cmd) {
    set_has_cmd();
    cmd_ = cmd;
  } else {
    clear_has_cmd();
    cmd_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string src_gs_id = 5;
inline bool GMMessageExecuteAck::has_src_gs_id() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void GMMessageExecuteAck::set_has_src_gs_id() {
  _has_bits_[0] |= 0x00000010u;
}
inline void GMMessageExecuteAck::clear_has_src_gs_id() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void GMMessageExecuteAck::clear_src_gs_id() {
  if (src_gs_id_ != &::google::protobuf::internal::kEmptyString) {
    src_gs_id_->clear();
  }
  clear_has_src_gs_id();
}
inline const ::std::string& GMMessageExecuteAck::src_gs_id() const {
  return *src_gs_id_;
}
inline void GMMessageExecuteAck::set_src_gs_id(const ::std::string& value) {
  set_has_src_gs_id();
  if (src_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    src_gs_id_ = new ::std::string;
  }
  src_gs_id_->assign(value);
}
inline void GMMessageExecuteAck::set_src_gs_id(const char* value) {
  set_has_src_gs_id();
  if (src_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    src_gs_id_ = new ::std::string;
  }
  src_gs_id_->assign(value);
}
inline void GMMessageExecuteAck::set_src_gs_id(const char* value, size_t size) {
  set_has_src_gs_id();
  if (src_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    src_gs_id_ = new ::std::string;
  }
  src_gs_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageExecuteAck::mutable_src_gs_id() {
  set_has_src_gs_id();
  if (src_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    src_gs_id_ = new ::std::string;
  }
  return src_gs_id_;
}
inline ::std::string* GMMessageExecuteAck::release_src_gs_id() {
  clear_has_src_gs_id();
  if (src_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = src_gs_id_;
    src_gs_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageExecuteAck::set_allocated_src_gs_id(::std::string* src_gs_id) {
  if (src_gs_id_ != &::google::protobuf::internal::kEmptyString) {
    delete src_gs_id_;
  }
  if (src_gs_id) {
    set_has_src_gs_id();
    src_gs_id_ = src_gs_id;
  } else {
    clear_has_src_gs_id();
    src_gs_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string dest_gs_id = 6;
inline bool GMMessageExecuteAck::has_dest_gs_id() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void GMMessageExecuteAck::set_has_dest_gs_id() {
  _has_bits_[0] |= 0x00000020u;
}
inline void GMMessageExecuteAck::clear_has_dest_gs_id() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void GMMessageExecuteAck::clear_dest_gs_id() {
  if (dest_gs_id_ != &::google::protobuf::internal::kEmptyString) {
    dest_gs_id_->clear();
  }
  clear_has_dest_gs_id();
}
inline const ::std::string& GMMessageExecuteAck::dest_gs_id() const {
  return *dest_gs_id_;
}
inline void GMMessageExecuteAck::set_dest_gs_id(const ::std::string& value) {
  set_has_dest_gs_id();
  if (dest_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    dest_gs_id_ = new ::std::string;
  }
  dest_gs_id_->assign(value);
}
inline void GMMessageExecuteAck::set_dest_gs_id(const char* value) {
  set_has_dest_gs_id();
  if (dest_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    dest_gs_id_ = new ::std::string;
  }
  dest_gs_id_->assign(value);
}
inline void GMMessageExecuteAck::set_dest_gs_id(const char* value, size_t size) {
  set_has_dest_gs_id();
  if (dest_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    dest_gs_id_ = new ::std::string;
  }
  dest_gs_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageExecuteAck::mutable_dest_gs_id() {
  set_has_dest_gs_id();
  if (dest_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    dest_gs_id_ = new ::std::string;
  }
  return dest_gs_id_;
}
inline ::std::string* GMMessageExecuteAck::release_dest_gs_id() {
  clear_has_dest_gs_id();
  if (dest_gs_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = dest_gs_id_;
    dest_gs_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageExecuteAck::set_allocated_dest_gs_id(::std::string* dest_gs_id) {
  if (dest_gs_id_ != &::google::protobuf::internal::kEmptyString) {
    delete dest_gs_id_;
  }
  if (dest_gs_id) {
    set_has_dest_gs_id();
    dest_gs_id_ = dest_gs_id;
  } else {
    clear_has_dest_gs_id();
    dest_gs_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 to_client_message_id = 7;
inline bool GMMessageExecuteAck::has_to_client_message_id() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void GMMessageExecuteAck::set_has_to_client_message_id() {
  _has_bits_[0] |= 0x00000040u;
}
inline void GMMessageExecuteAck::clear_has_to_client_message_id() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void GMMessageExecuteAck::clear_to_client_message_id() {
  to_client_message_id_ = 0;
  clear_has_to_client_message_id();
}
inline ::google::protobuf::int32 GMMessageExecuteAck::to_client_message_id() const {
  return to_client_message_id_;
}
inline void GMMessageExecuteAck::set_to_client_message_id(::google::protobuf::int32 value) {
  set_has_to_client_message_id();
  to_client_message_id_ = value;
}

// optional bytes to_client_message = 8;
inline bool GMMessageExecuteAck::has_to_client_message() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void GMMessageExecuteAck::set_has_to_client_message() {
  _has_bits_[0] |= 0x00000080u;
}
inline void GMMessageExecuteAck::clear_has_to_client_message() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void GMMessageExecuteAck::clear_to_client_message() {
  if (to_client_message_ != &::google::protobuf::internal::kEmptyString) {
    to_client_message_->clear();
  }
  clear_has_to_client_message();
}
inline const ::std::string& GMMessageExecuteAck::to_client_message() const {
  return *to_client_message_;
}
inline void GMMessageExecuteAck::set_to_client_message(const ::std::string& value) {
  set_has_to_client_message();
  if (to_client_message_ == &::google::protobuf::internal::kEmptyString) {
    to_client_message_ = new ::std::string;
  }
  to_client_message_->assign(value);
}
inline void GMMessageExecuteAck::set_to_client_message(const char* value) {
  set_has_to_client_message();
  if (to_client_message_ == &::google::protobuf::internal::kEmptyString) {
    to_client_message_ = new ::std::string;
  }
  to_client_message_->assign(value);
}
inline void GMMessageExecuteAck::set_to_client_message(const void* value, size_t size) {
  set_has_to_client_message();
  if (to_client_message_ == &::google::protobuf::internal::kEmptyString) {
    to_client_message_ = new ::std::string;
  }
  to_client_message_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GMMessageExecuteAck::mutable_to_client_message() {
  set_has_to_client_message();
  if (to_client_message_ == &::google::protobuf::internal::kEmptyString) {
    to_client_message_ = new ::std::string;
  }
  return to_client_message_;
}
inline ::std::string* GMMessageExecuteAck::release_to_client_message() {
  clear_has_to_client_message();
  if (to_client_message_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = to_client_message_;
    to_client_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GMMessageExecuteAck::set_allocated_to_client_message(::std::string* to_client_message) {
  if (to_client_message_ != &::google::protobuf::internal::kEmptyString) {
    delete to_client_message_;
  }
  if (to_client_message) {
    set_has_to_client_message();
    to_client_message_ = to_client_message;
  } else {
    clear_has_to_client_message();
    to_client_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// GetGSOnlinePlayerNumberReq

// optional int32 kind = 1;
inline bool GetGSOnlinePlayerNumberReq::has_kind() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetGSOnlinePlayerNumberReq::set_has_kind() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetGSOnlinePlayerNumberReq::clear_has_kind() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetGSOnlinePlayerNumberReq::clear_kind() {
  kind_ = 0;
  clear_has_kind();
}
inline ::google::protobuf::int32 GetGSOnlinePlayerNumberReq::kind() const {
  return kind_;
}
inline void GetGSOnlinePlayerNumberReq::set_kind(::google::protobuf::int32 value) {
  set_has_kind();
  kind_ = value;
}

// optional uint64 playerid = 2;
inline bool GetGSOnlinePlayerNumberReq::has_playerid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetGSOnlinePlayerNumberReq::set_has_playerid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetGSOnlinePlayerNumberReq::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetGSOnlinePlayerNumberReq::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 GetGSOnlinePlayerNumberReq::playerid() const {
  return playerid_;
}
inline void GetGSOnlinePlayerNumberReq::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// GSPlayerNumber

// optional string gs = 1;
inline bool GSPlayerNumber::has_gs() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GSPlayerNumber::set_has_gs() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GSPlayerNumber::clear_has_gs() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GSPlayerNumber::clear_gs() {
  if (gs_ != &::google::protobuf::internal::kEmptyString) {
    gs_->clear();
  }
  clear_has_gs();
}
inline const ::std::string& GSPlayerNumber::gs() const {
  return *gs_;
}
inline void GSPlayerNumber::set_gs(const ::std::string& value) {
  set_has_gs();
  if (gs_ == &::google::protobuf::internal::kEmptyString) {
    gs_ = new ::std::string;
  }
  gs_->assign(value);
}
inline void GSPlayerNumber::set_gs(const char* value) {
  set_has_gs();
  if (gs_ == &::google::protobuf::internal::kEmptyString) {
    gs_ = new ::std::string;
  }
  gs_->assign(value);
}
inline void GSPlayerNumber::set_gs(const char* value, size_t size) {
  set_has_gs();
  if (gs_ == &::google::protobuf::internal::kEmptyString) {
    gs_ = new ::std::string;
  }
  gs_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GSPlayerNumber::mutable_gs() {
  set_has_gs();
  if (gs_ == &::google::protobuf::internal::kEmptyString) {
    gs_ = new ::std::string;
  }
  return gs_;
}
inline ::std::string* GSPlayerNumber::release_gs() {
  clear_has_gs();
  if (gs_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = gs_;
    gs_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GSPlayerNumber::set_allocated_gs(::std::string* gs) {
  if (gs_ != &::google::protobuf::internal::kEmptyString) {
    delete gs_;
  }
  if (gs) {
    set_has_gs();
    gs_ = gs;
  } else {
    clear_has_gs();
    gs_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string gsname = 2;
inline bool GSPlayerNumber::has_gsname() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GSPlayerNumber::set_has_gsname() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GSPlayerNumber::clear_has_gsname() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GSPlayerNumber::clear_gsname() {
  if (gsname_ != &::google::protobuf::internal::kEmptyString) {
    gsname_->clear();
  }
  clear_has_gsname();
}
inline const ::std::string& GSPlayerNumber::gsname() const {
  return *gsname_;
}
inline void GSPlayerNumber::set_gsname(const ::std::string& value) {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  gsname_->assign(value);
}
inline void GSPlayerNumber::set_gsname(const char* value) {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  gsname_->assign(value);
}
inline void GSPlayerNumber::set_gsname(const char* value, size_t size) {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  gsname_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GSPlayerNumber::mutable_gsname() {
  set_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    gsname_ = new ::std::string;
  }
  return gsname_;
}
inline ::std::string* GSPlayerNumber::release_gsname() {
  clear_has_gsname();
  if (gsname_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = gsname_;
    gsname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void GSPlayerNumber::set_allocated_gsname(::std::string* gsname) {
  if (gsname_ != &::google::protobuf::internal::kEmptyString) {
    delete gsname_;
  }
  if (gsname) {
    set_has_gsname();
    gsname_ = gsname;
  } else {
    clear_has_gsname();
    gsname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 number = 3;
inline bool GSPlayerNumber::has_number() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GSPlayerNumber::set_has_number() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GSPlayerNumber::clear_has_number() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GSPlayerNumber::clear_number() {
  number_ = 0;
  clear_has_number();
}
inline ::google::protobuf::int32 GSPlayerNumber::number() const {
  return number_;
}
inline void GSPlayerNumber::set_number(::google::protobuf::int32 value) {
  set_has_number();
  number_ = value;
}

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

// GSOnlinePlayerNumberRpt

// repeated .protoc.gs_dbs.GSPlayerNumber gsn = 1;
inline int GSOnlinePlayerNumberRpt::gsn_size() const {
  return gsn_.size();
}
inline void GSOnlinePlayerNumberRpt::clear_gsn() {
  gsn_.Clear();
}
inline const ::protoc::gs_dbs::GSPlayerNumber& GSOnlinePlayerNumberRpt::gsn(int index) const {
  return gsn_.Get(index);
}
inline ::protoc::gs_dbs::GSPlayerNumber* GSOnlinePlayerNumberRpt::mutable_gsn(int index) {
  return gsn_.Mutable(index);
}
inline ::protoc::gs_dbs::GSPlayerNumber* GSOnlinePlayerNumberRpt::add_gsn() {
  return gsn_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GSPlayerNumber >&
GSOnlinePlayerNumberRpt::gsn() const {
  return gsn_;
}
inline ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::GSPlayerNumber >*
GSOnlinePlayerNumberRpt::mutable_gsn() {
  return &gsn_;
}

// optional uint64 playerid = 2;
inline bool GSOnlinePlayerNumberRpt::has_playerid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GSOnlinePlayerNumberRpt::set_has_playerid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GSOnlinePlayerNumberRpt::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GSOnlinePlayerNumberRpt::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 GSOnlinePlayerNumberRpt::playerid() const {
  return playerid_;
}
inline void GSOnlinePlayerNumberRpt::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// OtherGSOnlinePlayerRpt

// optional int32 isonline = 1;
inline bool OtherGSOnlinePlayerRpt::has_isonline() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OtherGSOnlinePlayerRpt::set_has_isonline() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OtherGSOnlinePlayerRpt::clear_has_isonline() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OtherGSOnlinePlayerRpt::clear_isonline() {
  isonline_ = 0;
  clear_has_isonline();
}
inline ::google::protobuf::int32 OtherGSOnlinePlayerRpt::isonline() const {
  return isonline_;
}
inline void OtherGSOnlinePlayerRpt::set_isonline(::google::protobuf::int32 value) {
  set_has_isonline();
  isonline_ = value;
}

// repeated uint64 playerid = 2;
inline int OtherGSOnlinePlayerRpt::playerid_size() const {
  return playerid_.size();
}
inline void OtherGSOnlinePlayerRpt::clear_playerid() {
  playerid_.Clear();
}
inline ::google::protobuf::uint64 OtherGSOnlinePlayerRpt::playerid(int index) const {
  return playerid_.Get(index);
}
inline void OtherGSOnlinePlayerRpt::set_playerid(int index, ::google::protobuf::uint64 value) {
  playerid_.Set(index, value);
}
inline void OtherGSOnlinePlayerRpt::add_playerid(::google::protobuf::uint64 value) {
  playerid_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
OtherGSOnlinePlayerRpt::playerid() const {
  return playerid_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
OtherGSOnlinePlayerRpt::mutable_playerid() {
  return &playerid_;
}

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

// OtherGSPlayerOnlineRpt

// optional uint64 playerid = 1;
inline bool OtherGSPlayerOnlineRpt::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OtherGSPlayerOnlineRpt::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OtherGSPlayerOnlineRpt::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OtherGSPlayerOnlineRpt::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 OtherGSPlayerOnlineRpt::playerid() const {
  return playerid_;
}
inline void OtherGSPlayerOnlineRpt::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// OtherGSPlayerOfflineRpt

// optional uint64 playerid = 1;
inline bool OtherGSPlayerOfflineRpt::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OtherGSPlayerOfflineRpt::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OtherGSPlayerOfflineRpt::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OtherGSPlayerOfflineRpt::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 OtherGSPlayerOfflineRpt::playerid() const {
  return playerid_;
}
inline void OtherGSPlayerOfflineRpt::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// ChongZhiPlayer

// optional uint64 transaction_id = 1;
inline bool ChongZhiPlayer::has_transaction_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChongZhiPlayer::set_has_transaction_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ChongZhiPlayer::clear_has_transaction_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ChongZhiPlayer::clear_transaction_id() {
  transaction_id_ = GOOGLE_ULONGLONG(0);
  clear_has_transaction_id();
}
inline ::google::protobuf::uint64 ChongZhiPlayer::transaction_id() const {
  return transaction_id_;
}
inline void ChongZhiPlayer::set_transaction_id(::google::protobuf::uint64 value) {
  set_has_transaction_id();
  transaction_id_ = value;
}

// optional uint64 playerid = 2;
inline bool ChongZhiPlayer::has_playerid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ChongZhiPlayer::set_has_playerid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ChongZhiPlayer::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ChongZhiPlayer::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 ChongZhiPlayer::playerid() const {
  return playerid_;
}
inline void ChongZhiPlayer::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// OfflineChongZhiNtf

// optional uint32 area_no = 1;
inline bool OfflineChongZhiNtf::has_area_no() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OfflineChongZhiNtf::set_has_area_no() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OfflineChongZhiNtf::clear_has_area_no() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OfflineChongZhiNtf::clear_area_no() {
  area_no_ = 0u;
  clear_has_area_no();
}
inline ::google::protobuf::uint32 OfflineChongZhiNtf::area_no() const {
  return area_no_;
}
inline void OfflineChongZhiNtf::set_area_no(::google::protobuf::uint32 value) {
  set_has_area_no();
  area_no_ = value;
}

// repeated .protoc.gs_dbs.ChongZhiPlayer chongzhi_user = 2;
inline int OfflineChongZhiNtf::chongzhi_user_size() const {
  return chongzhi_user_.size();
}
inline void OfflineChongZhiNtf::clear_chongzhi_user() {
  chongzhi_user_.Clear();
}
inline const ::protoc::gs_dbs::ChongZhiPlayer& OfflineChongZhiNtf::chongzhi_user(int index) const {
  return chongzhi_user_.Get(index);
}
inline ::protoc::gs_dbs::ChongZhiPlayer* OfflineChongZhiNtf::mutable_chongzhi_user(int index) {
  return chongzhi_user_.Mutable(index);
}
inline ::protoc::gs_dbs::ChongZhiPlayer* OfflineChongZhiNtf::add_chongzhi_user() {
  return chongzhi_user_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::ChongZhiPlayer >&
OfflineChongZhiNtf::chongzhi_user() const {
  return chongzhi_user_;
}
inline ::google::protobuf::RepeatedPtrField< ::protoc::gs_dbs::ChongZhiPlayer >*
OfflineChongZhiNtf::mutable_chongzhi_user() {
  return &chongzhi_user_;
}

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

// PlayerLeaveGameRpt

// optional uint64 playerid = 1;
inline bool PlayerLeaveGameRpt::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PlayerLeaveGameRpt::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PlayerLeaveGameRpt::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PlayerLeaveGameRpt::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 PlayerLeaveGameRpt::playerid() const {
  return playerid_;
}
inline void PlayerLeaveGameRpt::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// GetGM_ListReq

// optional uint64 playerid = 1;
inline bool GetGM_ListReq::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetGM_ListReq::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetGM_ListReq::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetGM_ListReq::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 GetGM_ListReq::playerid() const {
  return playerid_;
}
inline void GetGM_ListReq::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// GetGM_ListAck

// optional uint64 playerid = 1;
inline bool GetGM_ListAck::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetGM_ListAck::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetGM_ListAck::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetGM_ListAck::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 GetGM_ListAck::playerid() const {
  return playerid_;
}
inline void GetGM_ListAck::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// optional int32 err_no = 2;
inline bool GetGM_ListAck::has_err_no() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetGM_ListAck::set_has_err_no() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetGM_ListAck::clear_has_err_no() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetGM_ListAck::clear_err_no() {
  err_no_ = 0;
  clear_has_err_no();
}
inline ::google::protobuf::int32 GetGM_ListAck::err_no() const {
  return err_no_;
}
inline void GetGM_ListAck::set_err_no(::google::protobuf::int32 value) {
  set_has_err_no();
  err_no_ = value;
}

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

// DBSServerCloseNtf

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

// CheckInGSReq

// optional uint64 playerid = 3;
inline bool CheckInGSReq::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CheckInGSReq::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CheckInGSReq::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CheckInGSReq::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 CheckInGSReq::playerid() const {
  return playerid_;
}
inline void CheckInGSReq::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// CheckInGSAck

// optional uint64 playerid = 3;
inline bool CheckInGSAck::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CheckInGSAck::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CheckInGSAck::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CheckInGSAck::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 CheckInGSAck::playerid() const {
  return playerid_;
}
inline void CheckInGSAck::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// get_login_key_req

// optional uint64 playerid = 1;
inline bool get_login_key_req::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void get_login_key_req::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void get_login_key_req::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void get_login_key_req::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 get_login_key_req::playerid() const {
  return playerid_;
}
inline void get_login_key_req::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

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

// get_login_key_ack

// optional uint64 playerid = 1;
inline bool get_login_key_ack::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void get_login_key_ack::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void get_login_key_ack::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void get_login_key_ack::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 get_login_key_ack::playerid() const {
  return playerid_;
}
inline void get_login_key_ack::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// optional string key = 2;
inline bool get_login_key_ack::has_key() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void get_login_key_ack::set_has_key() {
  _has_bits_[0] |= 0x00000002u;
}
inline void get_login_key_ack::clear_has_key() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void get_login_key_ack::clear_key() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    key_->clear();
  }
  clear_has_key();
}
inline const ::std::string& get_login_key_ack::key() const {
  return *key_;
}
inline void get_login_key_ack::set_key(const ::std::string& value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void get_login_key_ack::set_key(const char* value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void get_login_key_ack::set_key(const char* value, size_t size) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* get_login_key_ack::mutable_key() {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  return key_;
}
inline ::std::string* get_login_key_ack::release_key() {
  clear_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = key_;
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void get_login_key_ack::set_allocated_key(::std::string* key) {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (key) {
    set_has_key();
    key_ = key;
  } else {
    clear_has_key();
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 leave_time = 3;
inline bool get_login_key_ack::has_leave_time() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void get_login_key_ack::set_has_leave_time() {
  _has_bits_[0] |= 0x00000004u;
}
inline void get_login_key_ack::clear_has_leave_time() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void get_login_key_ack::clear_leave_time() {
  leave_time_ = 0;
  clear_has_leave_time();
}
inline ::google::protobuf::int32 get_login_key_ack::leave_time() const {
  return leave_time_;
}
inline void get_login_key_ack::set_leave_time(::google::protobuf::int32 value) {
  set_has_leave_time();
  leave_time_ = value;
}

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

// login_gs_req

// optional uint64 playerid = 1;
inline bool login_gs_req::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void login_gs_req::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void login_gs_req::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void login_gs_req::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 login_gs_req::playerid() const {
  return playerid_;
}
inline void login_gs_req::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// optional string account = 2;
inline bool login_gs_req::has_account() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void login_gs_req::set_has_account() {
  _has_bits_[0] |= 0x00000002u;
}
inline void login_gs_req::clear_has_account() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void login_gs_req::clear_account() {
  if (account_ != &::google::protobuf::internal::kEmptyString) {
    account_->clear();
  }
  clear_has_account();
}
inline const ::std::string& login_gs_req::account() const {
  return *account_;
}
inline void login_gs_req::set_account(const ::std::string& value) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(value);
}
inline void login_gs_req::set_account(const char* value) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(value);
}
inline void login_gs_req::set_account(const char* value, size_t size) {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  account_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* login_gs_req::mutable_account() {
  set_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    account_ = new ::std::string;
  }
  return account_;
}
inline ::std::string* login_gs_req::release_account() {
  clear_has_account();
  if (account_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = account_;
    account_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void login_gs_req::set_allocated_account(::std::string* account) {
  if (account_ != &::google::protobuf::internal::kEmptyString) {
    delete account_;
  }
  if (account) {
    set_has_account();
    account_ = account;
  } else {
    clear_has_account();
    account_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 area_id = 3;
inline bool login_gs_req::has_area_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void login_gs_req::set_has_area_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void login_gs_req::clear_has_area_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void login_gs_req::clear_area_id() {
  area_id_ = 0u;
  clear_has_area_id();
}
inline ::google::protobuf::uint32 login_gs_req::area_id() const {
  return area_id_;
}
inline void login_gs_req::set_area_id(::google::protobuf::uint32 value) {
  set_has_area_id();
  area_id_ = value;
}

// optional int32 platform_id = 4;
inline bool login_gs_req::has_platform_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void login_gs_req::set_has_platform_id() {
  _has_bits_[0] |= 0x00000008u;
}
inline void login_gs_req::clear_has_platform_id() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void login_gs_req::clear_platform_id() {
  platform_id_ = 0;
  clear_has_platform_id();
}
inline ::google::protobuf::int32 login_gs_req::platform_id() const {
  return platform_id_;
}
inline void login_gs_req::set_platform_id(::google::protobuf::int32 value) {
  set_has_platform_id();
  platform_id_ = value;
}

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

// login_gs_ack

// optional uint64 playerid = 1;
inline bool login_gs_ack::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void login_gs_ack::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void login_gs_ack::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void login_gs_ack::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 login_gs_ack::playerid() const {
  return playerid_;
}
inline void login_gs_ack::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// optional string gate_ip = 2;
inline bool login_gs_ack::has_gate_ip() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void login_gs_ack::set_has_gate_ip() {
  _has_bits_[0] |= 0x00000002u;
}
inline void login_gs_ack::clear_has_gate_ip() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void login_gs_ack::clear_gate_ip() {
  if (gate_ip_ != &::google::protobuf::internal::kEmptyString) {
    gate_ip_->clear();
  }
  clear_has_gate_ip();
}
inline const ::std::string& login_gs_ack::gate_ip() const {
  return *gate_ip_;
}
inline void login_gs_ack::set_gate_ip(const ::std::string& value) {
  set_has_gate_ip();
  if (gate_ip_ == &::google::protobuf::internal::kEmptyString) {
    gate_ip_ = new ::std::string;
  }
  gate_ip_->assign(value);
}
inline void login_gs_ack::set_gate_ip(const char* value) {
  set_has_gate_ip();
  if (gate_ip_ == &::google::protobuf::internal::kEmptyString) {
    gate_ip_ = new ::std::string;
  }
  gate_ip_->assign(value);
}
inline void login_gs_ack::set_gate_ip(const char* value, size_t size) {
  set_has_gate_ip();
  if (gate_ip_ == &::google::protobuf::internal::kEmptyString) {
    gate_ip_ = new ::std::string;
  }
  gate_ip_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* login_gs_ack::mutable_gate_ip() {
  set_has_gate_ip();
  if (gate_ip_ == &::google::protobuf::internal::kEmptyString) {
    gate_ip_ = new ::std::string;
  }
  return gate_ip_;
}
inline ::std::string* login_gs_ack::release_gate_ip() {
  clear_has_gate_ip();
  if (gate_ip_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = gate_ip_;
    gate_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void login_gs_ack::set_allocated_gate_ip(::std::string* gate_ip) {
  if (gate_ip_ != &::google::protobuf::internal::kEmptyString) {
    delete gate_ip_;
  }
  if (gate_ip) {
    set_has_gate_ip();
    gate_ip_ = gate_ip;
  } else {
    clear_has_gate_ip();
    gate_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional int32 gateport = 3;
inline bool login_gs_ack::has_gateport() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void login_gs_ack::set_has_gateport() {
  _has_bits_[0] |= 0x00000004u;
}
inline void login_gs_ack::clear_has_gateport() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void login_gs_ack::clear_gateport() {
  gateport_ = 0;
  clear_has_gateport();
}
inline ::google::protobuf::int32 login_gs_ack::gateport() const {
  return gateport_;
}
inline void login_gs_ack::set_gateport(::google::protobuf::int32 value) {
  set_has_gateport();
  gateport_ = value;
}

// optional int32 gate_key = 4;
inline bool login_gs_ack::has_gate_key() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void login_gs_ack::set_has_gate_key() {
  _has_bits_[0] |= 0x00000008u;
}
inline void login_gs_ack::clear_has_gate_key() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void login_gs_ack::clear_gate_key() {
  gate_key_ = 0;
  clear_has_gate_key();
}
inline ::google::protobuf::int32 login_gs_ack::gate_key() const {
  return gate_key_;
}
inline void login_gs_ack::set_gate_key(::google::protobuf::int32 value) {
  set_has_gate_key();
  gate_key_ = value;
}

// optional int32 err_no = 5;
inline bool login_gs_ack::has_err_no() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void login_gs_ack::set_has_err_no() {
  _has_bits_[0] |= 0x00000010u;
}
inline void login_gs_ack::clear_has_err_no() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void login_gs_ack::clear_err_no() {
  err_no_ = 0;
  clear_has_err_no();
}
inline ::google::protobuf::int32 login_gs_ack::err_no() const {
  return err_no_;
}
inline void login_gs_ack::set_err_no(::google::protobuf::int32 value) {
  set_has_err_no();
  err_no_ = value;
}

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

// online_gs_rpt

// optional uint64 playerid = 1;
inline bool online_gs_rpt::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void online_gs_rpt::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void online_gs_rpt::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void online_gs_rpt::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 online_gs_rpt::playerid() const {
  return playerid_;
}
inline void online_gs_rpt::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// optional string gsid = 2;
inline bool online_gs_rpt::has_gsid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void online_gs_rpt::set_has_gsid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void online_gs_rpt::clear_has_gsid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void online_gs_rpt::clear_gsid() {
  if (gsid_ != &::google::protobuf::internal::kEmptyString) {
    gsid_->clear();
  }
  clear_has_gsid();
}
inline const ::std::string& online_gs_rpt::gsid() const {
  return *gsid_;
}
inline void online_gs_rpt::set_gsid(const ::std::string& value) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(value);
}
inline void online_gs_rpt::set_gsid(const char* value) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(value);
}
inline void online_gs_rpt::set_gsid(const char* value, size_t size) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* online_gs_rpt::mutable_gsid() {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  return gsid_;
}
inline ::std::string* online_gs_rpt::release_gsid() {
  clear_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = gsid_;
    gsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void online_gs_rpt::set_allocated_gsid(::std::string* gsid) {
  if (gsid_ != &::google::protobuf::internal::kEmptyString) {
    delete gsid_;
  }
  if (gsid) {
    set_has_gsid();
    gsid_ = gsid;
  } else {
    clear_has_gsid();
    gsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// switch_gs_lock_req

// optional uint64 playerid = 1;
inline bool switch_gs_lock_req::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void switch_gs_lock_req::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void switch_gs_lock_req::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void switch_gs_lock_req::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 switch_gs_lock_req::playerid() const {
  return playerid_;
}
inline void switch_gs_lock_req::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// optional string gsid = 2;
inline bool switch_gs_lock_req::has_gsid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void switch_gs_lock_req::set_has_gsid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void switch_gs_lock_req::clear_has_gsid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void switch_gs_lock_req::clear_gsid() {
  if (gsid_ != &::google::protobuf::internal::kEmptyString) {
    gsid_->clear();
  }
  clear_has_gsid();
}
inline const ::std::string& switch_gs_lock_req::gsid() const {
  return *gsid_;
}
inline void switch_gs_lock_req::set_gsid(const ::std::string& value) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(value);
}
inline void switch_gs_lock_req::set_gsid(const char* value) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(value);
}
inline void switch_gs_lock_req::set_gsid(const char* value, size_t size) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* switch_gs_lock_req::mutable_gsid() {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  return gsid_;
}
inline ::std::string* switch_gs_lock_req::release_gsid() {
  clear_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = gsid_;
    gsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void switch_gs_lock_req::set_allocated_gsid(::std::string* gsid) {
  if (gsid_ != &::google::protobuf::internal::kEmptyString) {
    delete gsid_;
  }
  if (gsid) {
    set_has_gsid();
    gsid_ = gsid;
  } else {
    clear_has_gsid();
    gsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// switch_gs_lock_ack

// optional uint64 playerid = 1;
inline bool switch_gs_lock_ack::has_playerid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void switch_gs_lock_ack::set_has_playerid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void switch_gs_lock_ack::clear_has_playerid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void switch_gs_lock_ack::clear_playerid() {
  playerid_ = GOOGLE_ULONGLONG(0);
  clear_has_playerid();
}
inline ::google::protobuf::uint64 switch_gs_lock_ack::playerid() const {
  return playerid_;
}
inline void switch_gs_lock_ack::set_playerid(::google::protobuf::uint64 value) {
  set_has_playerid();
  playerid_ = value;
}

// optional string gsid = 2;
inline bool switch_gs_lock_ack::has_gsid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void switch_gs_lock_ack::set_has_gsid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void switch_gs_lock_ack::clear_has_gsid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void switch_gs_lock_ack::clear_gsid() {
  if (gsid_ != &::google::protobuf::internal::kEmptyString) {
    gsid_->clear();
  }
  clear_has_gsid();
}
inline const ::std::string& switch_gs_lock_ack::gsid() const {
  return *gsid_;
}
inline void switch_gs_lock_ack::set_gsid(const ::std::string& value) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(value);
}
inline void switch_gs_lock_ack::set_gsid(const char* value) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(value);
}
inline void switch_gs_lock_ack::set_gsid(const char* value, size_t size) {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  gsid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* switch_gs_lock_ack::mutable_gsid() {
  set_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    gsid_ = new ::std::string;
  }
  return gsid_;
}
inline ::std::string* switch_gs_lock_ack::release_gsid() {
  clear_has_gsid();
  if (gsid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = gsid_;
    gsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void switch_gs_lock_ack::set_allocated_gsid(::std::string* gsid) {
  if (gsid_ != &::google::protobuf::internal::kEmptyString) {
    delete gsid_;
  }
  if (gsid) {
    set_has_gsid();
    gsid_ = gsid;
  } else {
    clear_has_gsid();
    gsid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// @@protoc_insertion_point(namespace_scope)

}  // namespace gs_dbs
}  // namespace protoc

#ifndef SWIG
namespace google {
namespace protobuf {

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_gameserver_5fdbserver_2eproto__INCLUDED