text:
namespace uuss {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_uuss_2eproto();
void protobuf_AssignDesc_uuss_2eproto();
void protobuf_ShutdownFile_uuss_2eproto();

class GetRequest;
class GetResponse;
class ReleaseLock;
class LockReleased;
class SaveRequest;
class SaveResponse;
class GetMessagesRequest;
class GetMessagesResponse;
class SendMessageRequest;
class SendMessageResponse;
class RemoveMessagesRequest;
class RemoveMessagesResponse;
class Ping;
class Pong;
class ExceptionResponse;
class DeleteRequest;
class DeleteResponse;

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

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

  GetRequest(const GetRequest& from);

  inline GetRequest& operator=(const GetRequest& 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 GetRequest& default_instance();

  void Swap(GetRequest* other);

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

  GetRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetRequest& from);
  void MergeFrom(const GetRequest& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // optional bool create_if_missing = 3 [default = false];
  inline bool has_create_if_missing() const;
  inline void clear_create_if_missing();
  static const int kCreateIfMissingFieldNumber = 3;
  inline bool create_if_missing() const;
  inline void set_create_if_missing(bool value);

  // optional bool lock = 4 [default = false];
  inline bool has_lock() const;
  inline void clear_lock();
  static const int kLockFieldNumber = 4;
  inline bool lock() const;
  inline void set_lock(bool value);

  // optional string lock_label = 5;
  inline bool has_lock_label() const;
  inline void clear_lock_label();
  static const int kLockLabelFieldNumber = 5;
  inline const ::std::string& lock_label() const;
  inline void set_lock_label(const ::std::string& value);
  inline void set_lock_label(const char* value);
  inline void set_lock_label(const char* value, size_t size);
  inline ::std::string* mutable_lock_label();
  inline ::std::string* release_lock_label();

  // optional int32 lock_timeout = 6 [default = 60];
  inline bool has_lock_timeout() const;
  inline void clear_lock_timeout();
  static const int kLockTimeoutFieldNumber = 6;
  inline ::google::protobuf::int32 lock_timeout() const;
  inline void set_lock_timeout(::google::protobuf::int32 value);

  // optional int32 lock_max_wait = 7 [default = 30];
  inline bool has_lock_max_wait() const;
  inline void clear_lock_max_wait();
  static const int kLockMaxWaitFieldNumber = 7;
  inline ::google::protobuf::int32 lock_max_wait() const;
  inline void set_lock_max_wait(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:uuss.GetRequest)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();
  inline void set_has_create_if_missing();
  inline void clear_has_create_if_missing();
  inline void set_has_lock();
  inline void clear_has_lock();
  inline void set_has_lock_label();
  inline void clear_has_lock_label();
  inline void set_has_lock_timeout();
  inline void clear_has_lock_timeout();
  inline void set_has_lock_max_wait();
  inline void clear_has_lock_max_wait();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;
  bool create_if_missing_;
  bool lock_;
  ::google::protobuf::int32 lock_timeout_;
  ::std::string* lock_label_;
  ::google::protobuf::int32 lock_max_wait_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  GetResponse(const GetResponse& from);

  inline GetResponse& operator=(const GetResponse& 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 GetResponse& default_instance();

  void Swap(GetResponse* other);

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

  GetResponse* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetResponse& from);
  void MergeFrom(const GetResponse& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // required bytes state = 3;
  inline bool has_state() const;
  inline void clear_state();
  static const int kStateFieldNumber = 3;
  inline const ::std::string& state() const;
  inline void set_state(const ::std::string& value);
  inline void set_state(const char* value);
  inline void set_state(const void* value, size_t size);
  inline ::std::string* mutable_state();
  inline ::std::string* release_state();

  // @@protoc_insertion_point(class_scope:uuss.GetResponse)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();
  inline void set_has_state();
  inline void clear_has_state();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;
  ::std::string* state_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  ReleaseLock(const ReleaseLock& from);

  inline ReleaseLock& operator=(const ReleaseLock& 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 ReleaseLock& default_instance();

  void Swap(ReleaseLock* other);

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

  ReleaseLock* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ReleaseLock& from);
  void MergeFrom(const ReleaseLock& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // @@protoc_insertion_point(class_scope:uuss.ReleaseLock)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  LockReleased(const LockReleased& from);

  inline LockReleased& operator=(const LockReleased& 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 LockReleased& default_instance();

  void Swap(LockReleased* other);

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

  LockReleased* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const LockReleased& from);
  void MergeFrom(const LockReleased& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // @@protoc_insertion_point(class_scope:uuss.LockReleased)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  SaveRequest(const SaveRequest& from);

  inline SaveRequest& operator=(const SaveRequest& 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 SaveRequest& default_instance();

  void Swap(SaveRequest* other);

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

  SaveRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SaveRequest& from);
  void MergeFrom(const SaveRequest& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // required bytes state = 3;
  inline bool has_state() const;
  inline void clear_state();
  static const int kStateFieldNumber = 3;
  inline const ::std::string& state() const;
  inline void set_state(const ::std::string& value);
  inline void set_state(const char* value);
  inline void set_state(const void* value, size_t size);
  inline ::std::string* mutable_state();
  inline ::std::string* release_state();

  // @@protoc_insertion_point(class_scope:uuss.SaveRequest)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();
  inline void set_has_state();
  inline void clear_has_state();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;
  ::std::string* state_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  SaveResponse(const SaveResponse& from);

  inline SaveResponse& operator=(const SaveResponse& 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 SaveResponse& default_instance();

  void Swap(SaveResponse* other);

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

  SaveResponse* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SaveResponse& from);
  void MergeFrom(const SaveResponse& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // @@protoc_insertion_point(class_scope:uuss.SaveResponse)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  GetMessagesRequest(const GetMessagesRequest& from);

  inline GetMessagesRequest& operator=(const GetMessagesRequest& 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 GetMessagesRequest& default_instance();

  void Swap(GetMessagesRequest* other);

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

  GetMessagesRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetMessagesRequest& from);
  void MergeFrom(const GetMessagesRequest& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // @@protoc_insertion_point(class_scope:uuss.GetMessagesRequest)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  GetMessagesResponse(const GetMessagesResponse& from);

  inline GetMessagesResponse& operator=(const GetMessagesResponse& 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 GetMessagesResponse& default_instance();

  void Swap(GetMessagesResponse* other);

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

  GetMessagesResponse* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GetMessagesResponse& from);
  void MergeFrom(const GetMessagesResponse& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // repeated string messages = 3;
  inline int messages_size() const;
  inline void clear_messages();
  static const int kMessagesFieldNumber = 3;
  inline const ::std::string& messages(int index) const;
  inline ::std::string* mutable_messages(int index);
  inline void set_messages(int index, const ::std::string& value);
  inline void set_messages(int index, const char* value);
  inline void set_messages(int index, const char* value, size_t size);
  inline ::std::string* add_messages();
  inline void add_messages(const ::std::string& value);
  inline void add_messages(const char* value);
  inline void add_messages(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& messages() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_messages();

  // @@protoc_insertion_point(class_scope:uuss.GetMessagesResponse)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;
  ::google::protobuf::RepeatedPtrField< ::std::string> messages_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  SendMessageRequest(const SendMessageRequest& from);

  inline SendMessageRequest& operator=(const SendMessageRequest& 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 SendMessageRequest& default_instance();

  void Swap(SendMessageRequest* other);

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

  SendMessageRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SendMessageRequest& from);
  void MergeFrom(const SendMessageRequest& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // required string source_game = 3;
  inline bool has_source_game() const;
  inline void clear_source_game();
  static const int kSourceGameFieldNumber = 3;
  inline const ::std::string& source_game() const;
  inline void set_source_game(const ::std::string& value);
  inline void set_source_game(const char* value);
  inline void set_source_game(const char* value, size_t size);
  inline ::std::string* mutable_source_game();
  inline ::std::string* release_source_game();

  // required string source_user_id = 4;
  inline bool has_source_user_id() const;
  inline void clear_source_user_id();
  static const int kSourceUserIdFieldNumber = 4;
  inline const ::std::string& source_user_id() const;
  inline void set_source_user_id(const ::std::string& value);
  inline void set_source_user_id(const char* value);
  inline void set_source_user_id(const char* value, size_t size);
  inline ::std::string* mutable_source_user_id();
  inline ::std::string* release_source_user_id();

  // required string message = 5;
  inline bool has_message() const;
  inline void clear_message();
  static const int kMessageFieldNumber = 5;
  inline const ::std::string& message() const;
  inline void set_message(const ::std::string& value);
  inline void set_message(const char* value);
  inline void set_message(const char* value, size_t size);
  inline ::std::string* mutable_message();
  inline ::std::string* release_message();

  // optional uint32 priority = 6 [default = 0];
  inline bool has_priority() const;
  inline void clear_priority();
  static const int kPriorityFieldNumber = 6;
  inline ::google::protobuf::uint32 priority() const;
  inline void set_priority(::google::protobuf::uint32 value);

  // optional string message_id = 7;
  inline bool has_message_id() const;
  inline void clear_message_id();
  static const int kMessageIdFieldNumber = 7;
  inline const ::std::string& message_id() const;
  inline void set_message_id(const ::std::string& value);
  inline void set_message_id(const char* value);
  inline void set_message_id(const char* value, size_t size);
  inline ::std::string* mutable_message_id();
  inline ::std::string* release_message_id();

  // @@protoc_insertion_point(class_scope:uuss.SendMessageRequest)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();
  inline void set_has_source_game();
  inline void clear_has_source_game();
  inline void set_has_source_user_id();
  inline void clear_has_source_user_id();
  inline void set_has_message();
  inline void clear_has_message();
  inline void set_has_priority();
  inline void clear_has_priority();
  inline void set_has_message_id();
  inline void clear_has_message_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;
  ::std::string* source_game_;
  ::std::string* source_user_id_;
  ::std::string* message_;
  ::std::string* message_id_;
  ::google::protobuf::uint32 priority_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  SendMessageResponse(const SendMessageResponse& from);

  inline SendMessageResponse& operator=(const SendMessageResponse& 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 SendMessageResponse& default_instance();

  void Swap(SendMessageResponse* other);

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

  SendMessageResponse* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SendMessageResponse& from);
  void MergeFrom(const SendMessageResponse& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // required string message_id = 3;
  inline bool has_message_id() const;
  inline void clear_message_id();
  static const int kMessageIdFieldNumber = 3;
  inline const ::std::string& message_id() const;
  inline void set_message_id(const ::std::string& value);
  inline void set_message_id(const char* value);
  inline void set_message_id(const char* value, size_t size);
  inline ::std::string* mutable_message_id();
  inline ::std::string* release_message_id();

  // @@protoc_insertion_point(class_scope:uuss.SendMessageResponse)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();
  inline void set_has_message_id();
  inline void clear_has_message_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;
  ::std::string* message_id_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  RemoveMessagesRequest(const RemoveMessagesRequest& from);

  inline RemoveMessagesRequest& operator=(const RemoveMessagesRequest& 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 RemoveMessagesRequest& default_instance();

  void Swap(RemoveMessagesRequest* other);

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

  RemoveMessagesRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RemoveMessagesRequest& from);
  void MergeFrom(const RemoveMessagesRequest& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // repeated string message_ids = 3;
  inline int message_ids_size() const;
  inline void clear_message_ids();
  static const int kMessageIdsFieldNumber = 3;
  inline const ::std::string& message_ids(int index) const;
  inline ::std::string* mutable_message_ids(int index);
  inline void set_message_ids(int index, const ::std::string& value);
  inline void set_message_ids(int index, const char* value);
  inline void set_message_ids(int index, const char* value, size_t size);
  inline ::std::string* add_message_ids();
  inline void add_message_ids(const ::std::string& value);
  inline void add_message_ids(const char* value);
  inline void add_message_ids(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& message_ids() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_message_ids();

  // @@protoc_insertion_point(class_scope:uuss.RemoveMessagesRequest)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;
  ::google::protobuf::RepeatedPtrField< ::std::string> message_ids_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  RemoveMessagesResponse(const RemoveMessagesResponse& from);

  inline RemoveMessagesResponse& operator=(const RemoveMessagesResponse& 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 RemoveMessagesResponse& default_instance();

  void Swap(RemoveMessagesResponse* other);

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

  RemoveMessagesResponse* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RemoveMessagesResponse& from);
  void MergeFrom(const RemoveMessagesResponse& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // @@protoc_insertion_point(class_scope:uuss.RemoveMessagesResponse)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  Ping(const Ping& from);

  inline Ping& operator=(const Ping& 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 Ping& default_instance();

  void Swap(Ping* other);

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

  Ping* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Ping& from);
  void MergeFrom(const Ping& 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 uint32 counter = 1;
  inline bool has_counter() const;
  inline void clear_counter();
  static const int kCounterFieldNumber = 1;
  inline ::google::protobuf::uint32 counter() const;
  inline void set_counter(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:uuss.Ping)
 private:
  inline void set_has_counter();
  inline void clear_has_counter();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 counter_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  Pong(const Pong& from);

  inline Pong& operator=(const Pong& 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 Pong& default_instance();

  void Swap(Pong* other);

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

  Pong* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Pong& from);
  void MergeFrom(const Pong& 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 uint32 counter = 1;
  inline bool has_counter() const;
  inline void clear_counter();
  static const int kCounterFieldNumber = 1;
  inline ::google::protobuf::uint32 counter() const;
  inline void set_counter(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:uuss.Pong)
 private:
  inline void set_has_counter();
  inline void clear_has_counter();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 counter_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  ExceptionResponse(const ExceptionResponse& from);

  inline ExceptionResponse& operator=(const ExceptionResponse& 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 ExceptionResponse& default_instance();

  void Swap(ExceptionResponse* other);

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

  ExceptionResponse* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ExceptionResponse& from);
  void MergeFrom(const ExceptionResponse& 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 message = 1;
  inline bool has_message() const;
  inline void clear_message();
  static const int kMessageFieldNumber = 1;
  inline const ::std::string& message() const;
  inline void set_message(const ::std::string& value);
  inline void set_message(const char* value);
  inline void set_message(const char* value, size_t size);
  inline ::std::string* mutable_message();
  inline ::std::string* release_message();

  // optional string traceback = 2;
  inline bool has_traceback() const;
  inline void clear_traceback();
  static const int kTracebackFieldNumber = 2;
  inline const ::std::string& traceback() const;
  inline void set_traceback(const ::std::string& value);
  inline void set_traceback(const char* value);
  inline void set_traceback(const char* value, size_t size);
  inline ::std::string* mutable_traceback();
  inline ::std::string* release_traceback();

  // @@protoc_insertion_point(class_scope:uuss.ExceptionResponse)
 private:
  inline void set_has_message();
  inline void clear_has_message();
  inline void set_has_traceback();
  inline void clear_has_traceback();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* message_;
  ::std::string* traceback_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  DeleteRequest(const DeleteRequest& from);

  inline DeleteRequest& operator=(const DeleteRequest& 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 DeleteRequest& default_instance();

  void Swap(DeleteRequest* other);

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

  DeleteRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DeleteRequest& from);
  void MergeFrom(const DeleteRequest& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // @@protoc_insertion_point(class_scope:uuss.DeleteRequest)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

  DeleteResponse(const DeleteResponse& from);

  inline DeleteResponse& operator=(const DeleteResponse& 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 DeleteResponse& default_instance();

  void Swap(DeleteResponse* other);

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

  DeleteResponse* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DeleteResponse& from);
  void MergeFrom(const DeleteResponse& 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 string game = 1;
  inline bool has_game() const;
  inline void clear_game();
  static const int kGameFieldNumber = 1;
  inline const ::std::string& game() const;
  inline void set_game(const ::std::string& value);
  inline void set_game(const char* value);
  inline void set_game(const char* value, size_t size);
  inline ::std::string* mutable_game();
  inline ::std::string* release_game();

  // required string user_id = 2;
  inline bool has_user_id() const;
  inline void clear_user_id();
  static const int kUserIdFieldNumber = 2;
  inline const ::std::string& user_id() const;
  inline void set_user_id(const ::std::string& value);
  inline void set_user_id(const char* value);
  inline void set_user_id(const char* value, size_t size);
  inline ::std::string* mutable_user_id();
  inline ::std::string* release_user_id();

  // @@protoc_insertion_point(class_scope:uuss.DeleteResponse)
 private:
  inline void set_has_game();
  inline void clear_has_game();
  inline void set_has_user_id();
  inline void clear_has_user_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* game_;
  ::std::string* user_id_;

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

  friend void  protobuf_AddDesc_uuss_2eproto();
  friend void protobuf_AssignDesc_uuss_2eproto();
  friend void protobuf_ShutdownFile_uuss_2eproto();

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

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

// GetRequest

// required string game = 1;
inline bool GetRequest::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetRequest::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetRequest::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetRequest::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& GetRequest::game() const {
  return *game_;
}
inline void GetRequest::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void GetRequest::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void GetRequest::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetRequest::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* GetRequest::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool GetRequest::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetRequest::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetRequest::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetRequest::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& GetRequest::user_id() const {
  return *user_id_;
}
inline void GetRequest::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void GetRequest::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void GetRequest::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetRequest::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* GetRequest::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional bool create_if_missing = 3 [default = false];
inline bool GetRequest::has_create_if_missing() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetRequest::set_has_create_if_missing() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetRequest::clear_has_create_if_missing() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetRequest::clear_create_if_missing() {
  create_if_missing_ = false;
  clear_has_create_if_missing();
}
inline bool GetRequest::create_if_missing() const {
  return create_if_missing_;
}
inline void GetRequest::set_create_if_missing(bool value) {
  set_has_create_if_missing();
  create_if_missing_ = value;
}

// optional bool lock = 4 [default = false];
inline bool GetRequest::has_lock() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GetRequest::set_has_lock() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GetRequest::clear_has_lock() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GetRequest::clear_lock() {
  lock_ = false;
  clear_has_lock();
}
inline bool GetRequest::lock() const {
  return lock_;
}
inline void GetRequest::set_lock(bool value) {
  set_has_lock();
  lock_ = value;
}

// optional string lock_label = 5;
inline bool GetRequest::has_lock_label() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void GetRequest::set_has_lock_label() {
  _has_bits_[0] |= 0x00000010u;
}
inline void GetRequest::clear_has_lock_label() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void GetRequest::clear_lock_label() {
  if (lock_label_ != &::google::protobuf::internal::kEmptyString) {
    lock_label_->clear();
  }
  clear_has_lock_label();
}
inline const ::std::string& GetRequest::lock_label() const {
  return *lock_label_;
}
inline void GetRequest::set_lock_label(const ::std::string& value) {
  set_has_lock_label();
  if (lock_label_ == &::google::protobuf::internal::kEmptyString) {
    lock_label_ = new ::std::string;
  }
  lock_label_->assign(value);
}
inline void GetRequest::set_lock_label(const char* value) {
  set_has_lock_label();
  if (lock_label_ == &::google::protobuf::internal::kEmptyString) {
    lock_label_ = new ::std::string;
  }
  lock_label_->assign(value);
}
inline void GetRequest::set_lock_label(const char* value, size_t size) {
  set_has_lock_label();
  if (lock_label_ == &::google::protobuf::internal::kEmptyString) {
    lock_label_ = new ::std::string;
  }
  lock_label_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetRequest::mutable_lock_label() {
  set_has_lock_label();
  if (lock_label_ == &::google::protobuf::internal::kEmptyString) {
    lock_label_ = new ::std::string;
  }
  return lock_label_;
}
inline ::std::string* GetRequest::release_lock_label() {
  clear_has_lock_label();
  if (lock_label_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = lock_label_;
    lock_label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional int32 lock_timeout = 6 [default = 60];
inline bool GetRequest::has_lock_timeout() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void GetRequest::set_has_lock_timeout() {
  _has_bits_[0] |= 0x00000020u;
}
inline void GetRequest::clear_has_lock_timeout() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void GetRequest::clear_lock_timeout() {
  lock_timeout_ = 60;
  clear_has_lock_timeout();
}
inline ::google::protobuf::int32 GetRequest::lock_timeout() const {
  return lock_timeout_;
}
inline void GetRequest::set_lock_timeout(::google::protobuf::int32 value) {
  set_has_lock_timeout();
  lock_timeout_ = value;
}

// optional int32 lock_max_wait = 7 [default = 30];
inline bool GetRequest::has_lock_max_wait() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void GetRequest::set_has_lock_max_wait() {
  _has_bits_[0] |= 0x00000040u;
}
inline void GetRequest::clear_has_lock_max_wait() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void GetRequest::clear_lock_max_wait() {
  lock_max_wait_ = 30;
  clear_has_lock_max_wait();
}
inline ::google::protobuf::int32 GetRequest::lock_max_wait() const {
  return lock_max_wait_;
}
inline void GetRequest::set_lock_max_wait(::google::protobuf::int32 value) {
  set_has_lock_max_wait();
  lock_max_wait_ = value;
}

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

// GetResponse

// required string game = 1;
inline bool GetResponse::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetResponse::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetResponse::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetResponse::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& GetResponse::game() const {
  return *game_;
}
inline void GetResponse::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void GetResponse::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void GetResponse::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetResponse::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* GetResponse::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool GetResponse::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetResponse::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetResponse::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetResponse::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& GetResponse::user_id() const {
  return *user_id_;
}
inline void GetResponse::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void GetResponse::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void GetResponse::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetResponse::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* GetResponse::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required bytes state = 3;
inline bool GetResponse::has_state() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetResponse::set_has_state() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetResponse::clear_has_state() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetResponse::clear_state() {
  if (state_ != &::google::protobuf::internal::kEmptyString) {
    state_->clear();
  }
  clear_has_state();
}
inline const ::std::string& GetResponse::state() const {
  return *state_;
}
inline void GetResponse::set_state(const ::std::string& value) {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  state_->assign(value);
}
inline void GetResponse::set_state(const char* value) {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  state_->assign(value);
}
inline void GetResponse::set_state(const void* value, size_t size) {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  state_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetResponse::mutable_state() {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  return state_;
}
inline ::std::string* GetResponse::release_state() {
  clear_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = state_;
    state_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// ReleaseLock

// required string game = 1;
inline bool ReleaseLock::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReleaseLock::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReleaseLock::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReleaseLock::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& ReleaseLock::game() const {
  return *game_;
}
inline void ReleaseLock::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void ReleaseLock::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void ReleaseLock::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ReleaseLock::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* ReleaseLock::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool ReleaseLock::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReleaseLock::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReleaseLock::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ReleaseLock::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& ReleaseLock::user_id() const {
  return *user_id_;
}
inline void ReleaseLock::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void ReleaseLock::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void ReleaseLock::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ReleaseLock::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* ReleaseLock::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// LockReleased

// required string game = 1;
inline bool LockReleased::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LockReleased::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LockReleased::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LockReleased::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& LockReleased::game() const {
  return *game_;
}
inline void LockReleased::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void LockReleased::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void LockReleased::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LockReleased::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* LockReleased::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool LockReleased::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LockReleased::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LockReleased::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LockReleased::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& LockReleased::user_id() const {
  return *user_id_;
}
inline void LockReleased::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void LockReleased::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void LockReleased::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* LockReleased::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* LockReleased::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// SaveRequest

// required string game = 1;
inline bool SaveRequest::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SaveRequest::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SaveRequest::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SaveRequest::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& SaveRequest::game() const {
  return *game_;
}
inline void SaveRequest::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void SaveRequest::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void SaveRequest::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SaveRequest::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* SaveRequest::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool SaveRequest::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SaveRequest::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SaveRequest::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SaveRequest::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& SaveRequest::user_id() const {
  return *user_id_;
}
inline void SaveRequest::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void SaveRequest::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void SaveRequest::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SaveRequest::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* SaveRequest::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required bytes state = 3;
inline bool SaveRequest::has_state() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SaveRequest::set_has_state() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SaveRequest::clear_has_state() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SaveRequest::clear_state() {
  if (state_ != &::google::protobuf::internal::kEmptyString) {
    state_->clear();
  }
  clear_has_state();
}
inline const ::std::string& SaveRequest::state() const {
  return *state_;
}
inline void SaveRequest::set_state(const ::std::string& value) {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  state_->assign(value);
}
inline void SaveRequest::set_state(const char* value) {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  state_->assign(value);
}
inline void SaveRequest::set_state(const void* value, size_t size) {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  state_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SaveRequest::mutable_state() {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  return state_;
}
inline ::std::string* SaveRequest::release_state() {
  clear_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = state_;
    state_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// SaveResponse

// required string game = 1;
inline bool SaveResponse::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SaveResponse::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SaveResponse::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SaveResponse::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& SaveResponse::game() const {
  return *game_;
}
inline void SaveResponse::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void SaveResponse::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void SaveResponse::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SaveResponse::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* SaveResponse::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool SaveResponse::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SaveResponse::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SaveResponse::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SaveResponse::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& SaveResponse::user_id() const {
  return *user_id_;
}
inline void SaveResponse::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void SaveResponse::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void SaveResponse::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SaveResponse::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* SaveResponse::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// GetMessagesRequest

// required string game = 1;
inline bool GetMessagesRequest::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetMessagesRequest::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetMessagesRequest::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetMessagesRequest::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& GetMessagesRequest::game() const {
  return *game_;
}
inline void GetMessagesRequest::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void GetMessagesRequest::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void GetMessagesRequest::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetMessagesRequest::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* GetMessagesRequest::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool GetMessagesRequest::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetMessagesRequest::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetMessagesRequest::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetMessagesRequest::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& GetMessagesRequest::user_id() const {
  return *user_id_;
}
inline void GetMessagesRequest::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void GetMessagesRequest::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void GetMessagesRequest::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetMessagesRequest::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* GetMessagesRequest::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// GetMessagesResponse

// required string game = 1;
inline bool GetMessagesResponse::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetMessagesResponse::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetMessagesResponse::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetMessagesResponse::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& GetMessagesResponse::game() const {
  return *game_;
}
inline void GetMessagesResponse::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void GetMessagesResponse::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void GetMessagesResponse::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetMessagesResponse::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* GetMessagesResponse::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool GetMessagesResponse::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetMessagesResponse::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetMessagesResponse::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetMessagesResponse::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& GetMessagesResponse::user_id() const {
  return *user_id_;
}
inline void GetMessagesResponse::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void GetMessagesResponse::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void GetMessagesResponse::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetMessagesResponse::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* GetMessagesResponse::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// repeated string messages = 3;
inline int GetMessagesResponse::messages_size() const {
  return messages_.size();
}
inline void GetMessagesResponse::clear_messages() {
  messages_.Clear();
}
inline const ::std::string& GetMessagesResponse::messages(int index) const {
  return messages_.Get(index);
}
inline ::std::string* GetMessagesResponse::mutable_messages(int index) {
  return messages_.Mutable(index);
}
inline void GetMessagesResponse::set_messages(int index, const ::std::string& value) {
  messages_.Mutable(index)->assign(value);
}
inline void GetMessagesResponse::set_messages(int index, const char* value) {
  messages_.Mutable(index)->assign(value);
}
inline void GetMessagesResponse::set_messages(int index, const char* value, size_t size) {
  messages_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* GetMessagesResponse::add_messages() {
  return messages_.Add();
}
inline void GetMessagesResponse::add_messages(const ::std::string& value) {
  messages_.Add()->assign(value);
}
inline void GetMessagesResponse::add_messages(const char* value) {
  messages_.Add()->assign(value);
}
inline void GetMessagesResponse::add_messages(const char* value, size_t size) {
  messages_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
GetMessagesResponse::messages() const {
  return messages_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
GetMessagesResponse::mutable_messages() {
  return &messages_;
}

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

// SendMessageRequest

// required string game = 1;
inline bool SendMessageRequest::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SendMessageRequest::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SendMessageRequest::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SendMessageRequest::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& SendMessageRequest::game() const {
  return *game_;
}
inline void SendMessageRequest::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void SendMessageRequest::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void SendMessageRequest::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SendMessageRequest::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* SendMessageRequest::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool SendMessageRequest::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SendMessageRequest::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SendMessageRequest::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SendMessageRequest::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& SendMessageRequest::user_id() const {
  return *user_id_;
}
inline void SendMessageRequest::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void SendMessageRequest::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void SendMessageRequest::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SendMessageRequest::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* SendMessageRequest::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string source_game = 3;
inline bool SendMessageRequest::has_source_game() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SendMessageRequest::set_has_source_game() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SendMessageRequest::clear_has_source_game() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SendMessageRequest::clear_source_game() {
  if (source_game_ != &::google::protobuf::internal::kEmptyString) {
    source_game_->clear();
  }
  clear_has_source_game();
}
inline const ::std::string& SendMessageRequest::source_game() const {
  return *source_game_;
}
inline void SendMessageRequest::set_source_game(const ::std::string& value) {
  set_has_source_game();
  if (source_game_ == &::google::protobuf::internal::kEmptyString) {
    source_game_ = new ::std::string;
  }
  source_game_->assign(value);
}
inline void SendMessageRequest::set_source_game(const char* value) {
  set_has_source_game();
  if (source_game_ == &::google::protobuf::internal::kEmptyString) {
    source_game_ = new ::std::string;
  }
  source_game_->assign(value);
}
inline void SendMessageRequest::set_source_game(const char* value, size_t size) {
  set_has_source_game();
  if (source_game_ == &::google::protobuf::internal::kEmptyString) {
    source_game_ = new ::std::string;
  }
  source_game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SendMessageRequest::mutable_source_game() {
  set_has_source_game();
  if (source_game_ == &::google::protobuf::internal::kEmptyString) {
    source_game_ = new ::std::string;
  }
  return source_game_;
}
inline ::std::string* SendMessageRequest::release_source_game() {
  clear_has_source_game();
  if (source_game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = source_game_;
    source_game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string source_user_id = 4;
inline bool SendMessageRequest::has_source_user_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SendMessageRequest::set_has_source_user_id() {
  _has_bits_[0] |= 0x00000008u;
}
inline void SendMessageRequest::clear_has_source_user_id() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void SendMessageRequest::clear_source_user_id() {
  if (source_user_id_ != &::google::protobuf::internal::kEmptyString) {
    source_user_id_->clear();
  }
  clear_has_source_user_id();
}
inline const ::std::string& SendMessageRequest::source_user_id() const {
  return *source_user_id_;
}
inline void SendMessageRequest::set_source_user_id(const ::std::string& value) {
  set_has_source_user_id();
  if (source_user_id_ == &::google::protobuf::internal::kEmptyString) {
    source_user_id_ = new ::std::string;
  }
  source_user_id_->assign(value);
}
inline void SendMessageRequest::set_source_user_id(const char* value) {
  set_has_source_user_id();
  if (source_user_id_ == &::google::protobuf::internal::kEmptyString) {
    source_user_id_ = new ::std::string;
  }
  source_user_id_->assign(value);
}
inline void SendMessageRequest::set_source_user_id(const char* value, size_t size) {
  set_has_source_user_id();
  if (source_user_id_ == &::google::protobuf::internal::kEmptyString) {
    source_user_id_ = new ::std::string;
  }
  source_user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SendMessageRequest::mutable_source_user_id() {
  set_has_source_user_id();
  if (source_user_id_ == &::google::protobuf::internal::kEmptyString) {
    source_user_id_ = new ::std::string;
  }
  return source_user_id_;
}
inline ::std::string* SendMessageRequest::release_source_user_id() {
  clear_has_source_user_id();
  if (source_user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = source_user_id_;
    source_user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string message = 5;
inline bool SendMessageRequest::has_message() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SendMessageRequest::set_has_message() {
  _has_bits_[0] |= 0x00000010u;
}
inline void SendMessageRequest::clear_has_message() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void SendMessageRequest::clear_message() {
  if (message_ != &::google::protobuf::internal::kEmptyString) {
    message_->clear();
  }
  clear_has_message();
}
inline const ::std::string& SendMessageRequest::message() const {
  return *message_;
}
inline void SendMessageRequest::set_message(const ::std::string& value) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::kEmptyString) {
    message_ = new ::std::string;
  }
  message_->assign(value);
}
inline void SendMessageRequest::set_message(const char* value) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::kEmptyString) {
    message_ = new ::std::string;
  }
  message_->assign(value);
}
inline void SendMessageRequest::set_message(const char* value, size_t size) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::kEmptyString) {
    message_ = new ::std::string;
  }
  message_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SendMessageRequest::mutable_message() {
  set_has_message();
  if (message_ == &::google::protobuf::internal::kEmptyString) {
    message_ = new ::std::string;
  }
  return message_;
}
inline ::std::string* SendMessageRequest::release_message() {
  clear_has_message();
  if (message_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = message_;
    message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional uint32 priority = 6 [default = 0];
inline bool SendMessageRequest::has_priority() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void SendMessageRequest::set_has_priority() {
  _has_bits_[0] |= 0x00000020u;
}
inline void SendMessageRequest::clear_has_priority() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void SendMessageRequest::clear_priority() {
  priority_ = 0u;
  clear_has_priority();
}
inline ::google::protobuf::uint32 SendMessageRequest::priority() const {
  return priority_;
}
inline void SendMessageRequest::set_priority(::google::protobuf::uint32 value) {
  set_has_priority();
  priority_ = value;
}

// optional string message_id = 7;
inline bool SendMessageRequest::has_message_id() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void SendMessageRequest::set_has_message_id() {
  _has_bits_[0] |= 0x00000040u;
}
inline void SendMessageRequest::clear_has_message_id() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void SendMessageRequest::clear_message_id() {
  if (message_id_ != &::google::protobuf::internal::kEmptyString) {
    message_id_->clear();
  }
  clear_has_message_id();
}
inline const ::std::string& SendMessageRequest::message_id() const {
  return *message_id_;
}
inline void SendMessageRequest::set_message_id(const ::std::string& value) {
  set_has_message_id();
  if (message_id_ == &::google::protobuf::internal::kEmptyString) {
    message_id_ = new ::std::string;
  }
  message_id_->assign(value);
}
inline void SendMessageRequest::set_message_id(const char* value) {
  set_has_message_id();
  if (message_id_ == &::google::protobuf::internal::kEmptyString) {
    message_id_ = new ::std::string;
  }
  message_id_->assign(value);
}
inline void SendMessageRequest::set_message_id(const char* value, size_t size) {
  set_has_message_id();
  if (message_id_ == &::google::protobuf::internal::kEmptyString) {
    message_id_ = new ::std::string;
  }
  message_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SendMessageRequest::mutable_message_id() {
  set_has_message_id();
  if (message_id_ == &::google::protobuf::internal::kEmptyString) {
    message_id_ = new ::std::string;
  }
  return message_id_;
}
inline ::std::string* SendMessageRequest::release_message_id() {
  clear_has_message_id();
  if (message_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = message_id_;
    message_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// SendMessageResponse

// required string game = 1;
inline bool SendMessageResponse::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SendMessageResponse::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SendMessageResponse::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SendMessageResponse::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& SendMessageResponse::game() const {
  return *game_;
}
inline void SendMessageResponse::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void SendMessageResponse::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void SendMessageResponse::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SendMessageResponse::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* SendMessageResponse::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool SendMessageResponse::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SendMessageResponse::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SendMessageResponse::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SendMessageResponse::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& SendMessageResponse::user_id() const {
  return *user_id_;
}
inline void SendMessageResponse::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void SendMessageResponse::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void SendMessageResponse::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SendMessageResponse::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* SendMessageResponse::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string message_id = 3;
inline bool SendMessageResponse::has_message_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SendMessageResponse::set_has_message_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SendMessageResponse::clear_has_message_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SendMessageResponse::clear_message_id() {
  if (message_id_ != &::google::protobuf::internal::kEmptyString) {
    message_id_->clear();
  }
  clear_has_message_id();
}
inline const ::std::string& SendMessageResponse::message_id() const {
  return *message_id_;
}
inline void SendMessageResponse::set_message_id(const ::std::string& value) {
  set_has_message_id();
  if (message_id_ == &::google::protobuf::internal::kEmptyString) {
    message_id_ = new ::std::string;
  }
  message_id_->assign(value);
}
inline void SendMessageResponse::set_message_id(const char* value) {
  set_has_message_id();
  if (message_id_ == &::google::protobuf::internal::kEmptyString) {
    message_id_ = new ::std::string;
  }
  message_id_->assign(value);
}
inline void SendMessageResponse::set_message_id(const char* value, size_t size) {
  set_has_message_id();
  if (message_id_ == &::google::protobuf::internal::kEmptyString) {
    message_id_ = new ::std::string;
  }
  message_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SendMessageResponse::mutable_message_id() {
  set_has_message_id();
  if (message_id_ == &::google::protobuf::internal::kEmptyString) {
    message_id_ = new ::std::string;
  }
  return message_id_;
}
inline ::std::string* SendMessageResponse::release_message_id() {
  clear_has_message_id();
  if (message_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = message_id_;
    message_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// RemoveMessagesRequest

// required string game = 1;
inline bool RemoveMessagesRequest::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RemoveMessagesRequest::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RemoveMessagesRequest::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RemoveMessagesRequest::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& RemoveMessagesRequest::game() const {
  return *game_;
}
inline void RemoveMessagesRequest::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void RemoveMessagesRequest::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void RemoveMessagesRequest::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RemoveMessagesRequest::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* RemoveMessagesRequest::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool RemoveMessagesRequest::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RemoveMessagesRequest::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RemoveMessagesRequest::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RemoveMessagesRequest::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& RemoveMessagesRequest::user_id() const {
  return *user_id_;
}
inline void RemoveMessagesRequest::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void RemoveMessagesRequest::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void RemoveMessagesRequest::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RemoveMessagesRequest::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* RemoveMessagesRequest::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// repeated string message_ids = 3;
inline int RemoveMessagesRequest::message_ids_size() const {
  return message_ids_.size();
}
inline void RemoveMessagesRequest::clear_message_ids() {
  message_ids_.Clear();
}
inline const ::std::string& RemoveMessagesRequest::message_ids(int index) const {
  return message_ids_.Get(index);
}
inline ::std::string* RemoveMessagesRequest::mutable_message_ids(int index) {
  return message_ids_.Mutable(index);
}
inline void RemoveMessagesRequest::set_message_ids(int index, const ::std::string& value) {
  message_ids_.Mutable(index)->assign(value);
}
inline void RemoveMessagesRequest::set_message_ids(int index, const char* value) {
  message_ids_.Mutable(index)->assign(value);
}
inline void RemoveMessagesRequest::set_message_ids(int index, const char* value, size_t size) {
  message_ids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RemoveMessagesRequest::add_message_ids() {
  return message_ids_.Add();
}
inline void RemoveMessagesRequest::add_message_ids(const ::std::string& value) {
  message_ids_.Add()->assign(value);
}
inline void RemoveMessagesRequest::add_message_ids(const char* value) {
  message_ids_.Add()->assign(value);
}
inline void RemoveMessagesRequest::add_message_ids(const char* value, size_t size) {
  message_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
RemoveMessagesRequest::message_ids() const {
  return message_ids_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
RemoveMessagesRequest::mutable_message_ids() {
  return &message_ids_;
}

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

// RemoveMessagesResponse

// required string game = 1;
inline bool RemoveMessagesResponse::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RemoveMessagesResponse::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RemoveMessagesResponse::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RemoveMessagesResponse::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& RemoveMessagesResponse::game() const {
  return *game_;
}
inline void RemoveMessagesResponse::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void RemoveMessagesResponse::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void RemoveMessagesResponse::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RemoveMessagesResponse::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* RemoveMessagesResponse::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool RemoveMessagesResponse::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RemoveMessagesResponse::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RemoveMessagesResponse::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RemoveMessagesResponse::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& RemoveMessagesResponse::user_id() const {
  return *user_id_;
}
inline void RemoveMessagesResponse::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void RemoveMessagesResponse::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void RemoveMessagesResponse::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RemoveMessagesResponse::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* RemoveMessagesResponse::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// Ping

// required uint32 counter = 1;
inline bool Ping::has_counter() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Ping::set_has_counter() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Ping::clear_has_counter() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Ping::clear_counter() {
  counter_ = 0u;
  clear_has_counter();
}
inline ::google::protobuf::uint32 Ping::counter() const {
  return counter_;
}
inline void Ping::set_counter(::google::protobuf::uint32 value) {
  set_has_counter();
  counter_ = value;
}

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

// Pong

// required uint32 counter = 1;
inline bool Pong::has_counter() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Pong::set_has_counter() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Pong::clear_has_counter() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Pong::clear_counter() {
  counter_ = 0u;
  clear_has_counter();
}
inline ::google::protobuf::uint32 Pong::counter() const {
  return counter_;
}
inline void Pong::set_counter(::google::protobuf::uint32 value) {
  set_has_counter();
  counter_ = value;
}

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

// ExceptionResponse

// optional string message = 1;
inline bool ExceptionResponse::has_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ExceptionResponse::set_has_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ExceptionResponse::clear_has_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ExceptionResponse::clear_message() {
  if (message_ != &::google::protobuf::internal::kEmptyString) {
    message_->clear();
  }
  clear_has_message();
}
inline const ::std::string& ExceptionResponse::message() const {
  return *message_;
}
inline void ExceptionResponse::set_message(const ::std::string& value) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::kEmptyString) {
    message_ = new ::std::string;
  }
  message_->assign(value);
}
inline void ExceptionResponse::set_message(const char* value) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::kEmptyString) {
    message_ = new ::std::string;
  }
  message_->assign(value);
}
inline void ExceptionResponse::set_message(const char* value, size_t size) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::kEmptyString) {
    message_ = new ::std::string;
  }
  message_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ExceptionResponse::mutable_message() {
  set_has_message();
  if (message_ == &::google::protobuf::internal::kEmptyString) {
    message_ = new ::std::string;
  }
  return message_;
}
inline ::std::string* ExceptionResponse::release_message() {
  clear_has_message();
  if (message_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = message_;
    message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string traceback = 2;
inline bool ExceptionResponse::has_traceback() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ExceptionResponse::set_has_traceback() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ExceptionResponse::clear_has_traceback() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ExceptionResponse::clear_traceback() {
  if (traceback_ != &::google::protobuf::internal::kEmptyString) {
    traceback_->clear();
  }
  clear_has_traceback();
}
inline const ::std::string& ExceptionResponse::traceback() const {
  return *traceback_;
}
inline void ExceptionResponse::set_traceback(const ::std::string& value) {
  set_has_traceback();
  if (traceback_ == &::google::protobuf::internal::kEmptyString) {
    traceback_ = new ::std::string;
  }
  traceback_->assign(value);
}
inline void ExceptionResponse::set_traceback(const char* value) {
  set_has_traceback();
  if (traceback_ == &::google::protobuf::internal::kEmptyString) {
    traceback_ = new ::std::string;
  }
  traceback_->assign(value);
}
inline void ExceptionResponse::set_traceback(const char* value, size_t size) {
  set_has_traceback();
  if (traceback_ == &::google::protobuf::internal::kEmptyString) {
    traceback_ = new ::std::string;
  }
  traceback_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ExceptionResponse::mutable_traceback() {
  set_has_traceback();
  if (traceback_ == &::google::protobuf::internal::kEmptyString) {
    traceback_ = new ::std::string;
  }
  return traceback_;
}
inline ::std::string* ExceptionResponse::release_traceback() {
  clear_has_traceback();
  if (traceback_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = traceback_;
    traceback_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// DeleteRequest

// required string game = 1;
inline bool DeleteRequest::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DeleteRequest::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DeleteRequest::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DeleteRequest::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& DeleteRequest::game() const {
  return *game_;
}
inline void DeleteRequest::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void DeleteRequest::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void DeleteRequest::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DeleteRequest::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* DeleteRequest::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool DeleteRequest::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DeleteRequest::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DeleteRequest::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DeleteRequest::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& DeleteRequest::user_id() const {
  return *user_id_;
}
inline void DeleteRequest::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void DeleteRequest::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void DeleteRequest::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DeleteRequest::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* DeleteRequest::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// DeleteResponse

// required string game = 1;
inline bool DeleteResponse::has_game() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DeleteResponse::set_has_game() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DeleteResponse::clear_has_game() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DeleteResponse::clear_game() {
  if (game_ != &::google::protobuf::internal::kEmptyString) {
    game_->clear();
  }
  clear_has_game();
}
inline const ::std::string& DeleteResponse::game() const {
  return *game_;
}
inline void DeleteResponse::set_game(const ::std::string& value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void DeleteResponse::set_game(const char* value) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(value);
}
inline void DeleteResponse::set_game(const char* value, size_t size) {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  game_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DeleteResponse::mutable_game() {
  set_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    game_ = new ::std::string;
  }
  return game_;
}
inline ::std::string* DeleteResponse::release_game() {
  clear_has_game();
  if (game_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_;
    game_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required string user_id = 2;
inline bool DeleteResponse::has_user_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DeleteResponse::set_has_user_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DeleteResponse::clear_has_user_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DeleteResponse::clear_user_id() {
  if (user_id_ != &::google::protobuf::internal::kEmptyString) {
    user_id_->clear();
  }
  clear_has_user_id();
}
inline const ::std::string& DeleteResponse::user_id() const {
  return *user_id_;
}
inline void DeleteResponse::set_user_id(const ::std::string& value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void DeleteResponse::set_user_id(const char* value) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(value);
}
inline void DeleteResponse::set_user_id(const char* value, size_t size) {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  user_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DeleteResponse::mutable_user_id() {
  set_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    user_id_ = new ::std::string;
  }
  return user_id_;
}
inline ::std::string* DeleteResponse::release_user_id() {
  clear_has_user_id();
  if (user_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = user_id_;
    user_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// @@protoc_insertion_point(namespace_scope)

}  // namespace uuss

#ifndef SWIG
namespace google {
namespace protobuf {

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_uuss_2eproto__INCLUDED