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

#ifndef PROTOBUF_netmine_2eproto__INCLUDED
#define PROTOBUF_netmine_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3000000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3000000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)

namespace nm {
namespace message {

// Internal implementation detail -- do not call these.
void protobuf_AddDesc_netmine_2eproto();
void protobuf_AssignDesc_netmine_2eproto();
void protobuf_ShutdownFile_netmine_2eproto();

class ChunkBytes;
class ChunkRequest;
class ClearAt;
class CursorMove;
class MessageWrapper;
class Player;
class SquareFlag;
class SquareOpen;
class Welcome;

enum MessageWrapper_Type {
  MessageWrapper_Type_CURSOR_MOVE = 1,
  MessageWrapper_Type_SQUARE_FLAG = 2,
  MessageWrapper_Type_SQUARE_OPEN = 3,
  MessageWrapper_Type_PLAYER_JOIN = 4,
  MessageWrapper_Type_PLAYER_QUIT = 5,
  MessageWrapper_Type_WELCOME = 6,
  MessageWrapper_Type_CHUNK_BYTES = 7,
  MessageWrapper_Type_CHUNK_REQUEST = 8,
  MessageWrapper_Type_CLEAR_AT = 9,
  MessageWrapper_Type_PLAYER_UPDATE = 10
};
bool MessageWrapper_Type_IsValid(int value);
const MessageWrapper_Type MessageWrapper_Type_Type_MIN = MessageWrapper_Type_CURSOR_MOVE;
const MessageWrapper_Type MessageWrapper_Type_Type_MAX = MessageWrapper_Type_PLAYER_UPDATE;
const int MessageWrapper_Type_Type_ARRAYSIZE = MessageWrapper_Type_Type_MAX + 1;

const ::google::protobuf::EnumDescriptor* MessageWrapper_Type_descriptor();
inline const ::std::string& MessageWrapper_Type_Name(MessageWrapper_Type value) {
  return ::google::protobuf::internal::NameOfEnum(
    MessageWrapper_Type_descriptor(), value);
}
inline bool MessageWrapper_Type_Parse(
    const ::std::string& name, MessageWrapper_Type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<MessageWrapper_Type>(
    MessageWrapper_Type_descriptor(), name, value);
}
// ===================================================================

class MessageWrapper : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:nm.message.MessageWrapper) */ {
 public:
  MessageWrapper();
  virtual ~MessageWrapper();

  MessageWrapper(const MessageWrapper& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(MessageWrapper* other);

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

  inline MessageWrapper* New() const { return New(NULL); }

  MessageWrapper* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const MessageWrapper& from);
  void MergeFrom(const MessageWrapper& 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* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MessageWrapper* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

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

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

  typedef MessageWrapper_Type Type;
  static const Type CURSOR_MOVE =
    MessageWrapper_Type_CURSOR_MOVE;
  static const Type SQUARE_FLAG =
    MessageWrapper_Type_SQUARE_FLAG;
  static const Type SQUARE_OPEN =
    MessageWrapper_Type_SQUARE_OPEN;
  static const Type PLAYER_JOIN =
    MessageWrapper_Type_PLAYER_JOIN;
  static const Type PLAYER_QUIT =
    MessageWrapper_Type_PLAYER_QUIT;
  static const Type WELCOME =
    MessageWrapper_Type_WELCOME;
  static const Type CHUNK_BYTES =
    MessageWrapper_Type_CHUNK_BYTES;
  static const Type CHUNK_REQUEST =
    MessageWrapper_Type_CHUNK_REQUEST;
  static const Type CLEAR_AT =
    MessageWrapper_Type_CLEAR_AT;
  static const Type PLAYER_UPDATE =
    MessageWrapper_Type_PLAYER_UPDATE;
  static inline bool Type_IsValid(int value) {
    return MessageWrapper_Type_IsValid(value);
  }
  static const Type Type_MIN =
    MessageWrapper_Type_Type_MIN;
  static const Type Type_MAX =
    MessageWrapper_Type_Type_MAX;
  static const int Type_ARRAYSIZE =
    MessageWrapper_Type_Type_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Type_descriptor() {
    return MessageWrapper_Type_descriptor();
  }
  static inline const ::std::string& Type_Name(Type value) {
    return MessageWrapper_Type_Name(value);
  }
  static inline bool Type_Parse(const ::std::string& name,
      Type* value) {
    return MessageWrapper_Type_Parse(name, value);
  }

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

  // required .nm.message.MessageWrapper.Type type = 1;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 1;
  ::nm::message::MessageWrapper_Type type() const;
  void set_type(::nm::message::MessageWrapper_Type value);

  // optional .nm.message.CursorMove cursorMove = 2;
  bool has_cursormove() const;
  void clear_cursormove();
  static const int kCursorMoveFieldNumber = 2;
  const ::nm::message::CursorMove& cursormove() const;
  ::nm::message::CursorMove* mutable_cursormove();
  ::nm::message::CursorMove* release_cursormove();
  void set_allocated_cursormove(::nm::message::CursorMove* cursormove);

  // optional .nm.message.SquareOpen squareOpen = 3;
  bool has_squareopen() const;
  void clear_squareopen();
  static const int kSquareOpenFieldNumber = 3;
  const ::nm::message::SquareOpen& squareopen() const;
  ::nm::message::SquareOpen* mutable_squareopen();
  ::nm::message::SquareOpen* release_squareopen();
  void set_allocated_squareopen(::nm::message::SquareOpen* squareopen);

  // optional .nm.message.ChunkBytes chunkBytes = 4;
  bool has_chunkbytes() const;
  void clear_chunkbytes();
  static const int kChunkBytesFieldNumber = 4;
  const ::nm::message::ChunkBytes& chunkbytes() const;
  ::nm::message::ChunkBytes* mutable_chunkbytes();
  ::nm::message::ChunkBytes* release_chunkbytes();
  void set_allocated_chunkbytes(::nm::message::ChunkBytes* chunkbytes);

  // optional .nm.message.SquareFlag squareFlag = 5;
  bool has_squareflag() const;
  void clear_squareflag();
  static const int kSquareFlagFieldNumber = 5;
  const ::nm::message::SquareFlag& squareflag() const;
  ::nm::message::SquareFlag* mutable_squareflag();
  ::nm::message::SquareFlag* release_squareflag();
  void set_allocated_squareflag(::nm::message::SquareFlag* squareflag);

  // optional .nm.message.Player playerJoin = 6;
  bool has_playerjoin() const;
  void clear_playerjoin();
  static const int kPlayerJoinFieldNumber = 6;
  const ::nm::message::Player& playerjoin() const;
  ::nm::message::Player* mutable_playerjoin();
  ::nm::message::Player* release_playerjoin();
  void set_allocated_playerjoin(::nm::message::Player* playerjoin);

  // optional .nm.message.Player playerQuit = 7;
  bool has_playerquit() const;
  void clear_playerquit();
  static const int kPlayerQuitFieldNumber = 7;
  const ::nm::message::Player& playerquit() const;
  ::nm::message::Player* mutable_playerquit();
  ::nm::message::Player* release_playerquit();
  void set_allocated_playerquit(::nm::message::Player* playerquit);

  // optional .nm.message.Welcome welcome = 8;
  bool has_welcome() const;
  void clear_welcome();
  static const int kWelcomeFieldNumber = 8;
  const ::nm::message::Welcome& welcome() const;
  ::nm::message::Welcome* mutable_welcome();
  ::nm::message::Welcome* release_welcome();
  void set_allocated_welcome(::nm::message::Welcome* welcome);

  // optional .nm.message.ChunkRequest chunkRequest = 9;
  bool has_chunkrequest() const;
  void clear_chunkrequest();
  static const int kChunkRequestFieldNumber = 9;
  const ::nm::message::ChunkRequest& chunkrequest() const;
  ::nm::message::ChunkRequest* mutable_chunkrequest();
  ::nm::message::ChunkRequest* release_chunkrequest();
  void set_allocated_chunkrequest(::nm::message::ChunkRequest* chunkrequest);

  // optional .nm.message.ClearAt clearAt = 10;
  bool has_clearat() const;
  void clear_clearat();
  static const int kClearAtFieldNumber = 10;
  const ::nm::message::ClearAt& clearat() const;
  ::nm::message::ClearAt* mutable_clearat();
  ::nm::message::ClearAt* release_clearat();
  void set_allocated_clearat(::nm::message::ClearAt* clearat);

  // optional .nm.message.Player player = 11;
  bool has_player() const;
  void clear_player();
  static const int kPlayerFieldNumber = 11;
  const ::nm::message::Player& player() const;
  ::nm::message::Player* mutable_player();
  ::nm::message::Player* release_player();
  void set_allocated_player(::nm::message::Player* player);

  // @@protoc_insertion_point(class_scope:nm.message.MessageWrapper)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_cursormove();
  inline void clear_has_cursormove();
  inline void set_has_squareopen();
  inline void clear_has_squareopen();
  inline void set_has_chunkbytes();
  inline void clear_has_chunkbytes();
  inline void set_has_squareflag();
  inline void clear_has_squareflag();
  inline void set_has_playerjoin();
  inline void clear_has_playerjoin();
  inline void set_has_playerquit();
  inline void clear_has_playerquit();
  inline void set_has_welcome();
  inline void clear_has_welcome();
  inline void set_has_chunkrequest();
  inline void clear_has_chunkrequest();
  inline void set_has_clearat();
  inline void clear_has_clearat();
  inline void set_has_player();
  inline void clear_has_player();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::nm::message::CursorMove* cursormove_;
  ::nm::message::SquareOpen* squareopen_;
  ::nm::message::ChunkBytes* chunkbytes_;
  ::nm::message::SquareFlag* squareflag_;
  ::nm::message::Player* playerjoin_;
  ::nm::message::Player* playerquit_;
  ::nm::message::Welcome* welcome_;
  ::nm::message::ChunkRequest* chunkrequest_;
  ::nm::message::ClearAt* clearat_;
  ::nm::message::Player* player_;
  int type_;
  friend void  protobuf_AddDesc_netmine_2eproto();
  friend void protobuf_AssignDesc_netmine_2eproto();
  friend void protobuf_ShutdownFile_netmine_2eproto();

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

class ClearAt : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:nm.message.ClearAt) */ {
 public:
  ClearAt();
  virtual ~ClearAt();

  ClearAt(const ClearAt& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(ClearAt* other);

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

  inline ClearAt* New() const { return New(NULL); }

  ClearAt* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ClearAt& from);
  void MergeFrom(const ClearAt& 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* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ClearAt* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

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

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

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

  // required int32 x = 1;
  bool has_x() const;
  void clear_x();
  static const int kXFieldNumber = 1;
  ::google::protobuf::int32 x() const;
  void set_x(::google::protobuf::int32 value);

  // required int32 y = 2;
  bool has_y() const;
  void clear_y();
  static const int kYFieldNumber = 2;
  ::google::protobuf::int32 y() const;
  void set_y(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:nm.message.ClearAt)
 private:
  inline void set_has_x();
  inline void clear_has_x();
  inline void set_has_y();
  inline void clear_has_y();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::int32 x_;
  ::google::protobuf::int32 y_;
  friend void  protobuf_AddDesc_netmine_2eproto();
  friend void protobuf_AssignDesc_netmine_2eproto();
  friend void protobuf_ShutdownFile_netmine_2eproto();

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

class ChunkRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:nm.message.ChunkRequest) */ {
 public:
  ChunkRequest();
  virtual ~ChunkRequest();

  ChunkRequest(const ChunkRequest& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(ChunkRequest* other);

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

  inline ChunkRequest* New() const { return New(NULL); }

  ChunkRequest* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ChunkRequest& from);
  void MergeFrom(const ChunkRequest& 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* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ChunkRequest* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

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

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

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

  // required int32 x = 1;
  bool has_x() const;
  void clear_x();
  static const int kXFieldNumber = 1;
  ::google::protobuf::int32 x() const;
  void set_x(::google::protobuf::int32 value);

  // required int32 y = 2;
  bool has_y() const;
  void clear_y();
  static const int kYFieldNumber = 2;
  ::google::protobuf::int32 y() const;
  void set_y(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:nm.message.ChunkRequest)
 private:
  inline void set_has_x();
  inline void clear_has_x();
  inline void set_has_y();
  inline void clear_has_y();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::int32 x_;
  ::google::protobuf::int32 y_;
  friend void  protobuf_AddDesc_netmine_2eproto();
  friend void protobuf_AssignDesc_netmine_2eproto();
  friend void protobuf_ShutdownFile_netmine_2eproto();

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

class ChunkBytes : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:nm.message.ChunkBytes) */ {
 public:
  ChunkBytes();
  virtual ~ChunkBytes();

  ChunkBytes(const ChunkBytes& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(ChunkBytes* other);

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

  inline ChunkBytes* New() const { return New(NULL); }

  ChunkBytes* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ChunkBytes& from);
  void MergeFrom(const ChunkBytes& 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* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ChunkBytes* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

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

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

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

  // required int32 x = 1;
  bool has_x() const;
  void clear_x();
  static const int kXFieldNumber = 1;
  ::google::protobuf::int32 x() const;
  void set_x(::google::protobuf::int32 value);

  // required int32 y = 2;
  bool has_y() const;
  void clear_y();
  static const int kYFieldNumber = 2;
  ::google::protobuf::int32 y() const;
  void set_y(::google::protobuf::int32 value);

  // required bytes data = 3;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 3;
  const ::std::string& data() const;
  void set_data(const ::std::string& value);
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  ::std::string* mutable_data();
  ::std::string* release_data();
  void set_allocated_data(::std::string* data);

  // @@protoc_insertion_point(class_scope:nm.message.ChunkBytes)
 private:
  inline void set_has_x();
  inline void clear_has_x();
  inline void set_has_y();
  inline void clear_has_y();
  inline void set_has_data();
  inline void clear_has_data();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::int32 x_;
  ::google::protobuf::int32 y_;
  ::google::protobuf::internal::ArenaStringPtr data_;
  friend void  protobuf_AddDesc_netmine_2eproto();
  friend void protobuf_AssignDesc_netmine_2eproto();
  friend void protobuf_ShutdownFile_netmine_2eproto();

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

class CursorMove : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:nm.message.CursorMove) */ {
 public:
  CursorMove();
  virtual ~CursorMove();

  CursorMove(const CursorMove& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(CursorMove* other);

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

  inline CursorMove* New() const { return New(NULL); }

  CursorMove* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CursorMove& from);
  void MergeFrom(const CursorMove& 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* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CursorMove* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

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

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

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

  // required int32 x = 1;
  bool has_x() const;
  void clear_x();
  static const int kXFieldNumber = 1;
  ::google::protobuf::int32 x() const;
  void set_x(::google::protobuf::int32 value);

  // required int32 y = 2;
  bool has_y() const;
  void clear_y();
  static const int kYFieldNumber = 2;
  ::google::protobuf::int32 y() const;
  void set_y(::google::protobuf::int32 value);

  // optional int32 id = 3;
  bool has_id() const;
  void clear_id();
  static const int kIdFieldNumber = 3;
  ::google::protobuf::int32 id() const;
  void set_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:nm.message.CursorMove)
 private:
  inline void set_has_x();
  inline void clear_has_x();
  inline void set_has_y();
  inline void clear_has_y();
  inline void set_has_id();
  inline void clear_has_id();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::int32 x_;
  ::google::protobuf::int32 y_;
  ::google::protobuf::int32 id_;
  friend void  protobuf_AddDesc_netmine_2eproto();
  friend void protobuf_AssignDesc_netmine_2eproto();
  friend void protobuf_ShutdownFile_netmine_2eproto();

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

class SquareOpen : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:nm.message.SquareOpen) */ {
 public:
  SquareOpen();
  virtual ~SquareOpen();

  SquareOpen(const SquareOpen& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(SquareOpen* other);

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

  inline SquareOpen* New() const { return New(NULL); }

  SquareOpen* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SquareOpen& from);
  void MergeFrom(const SquareOpen& 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* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SquareOpen* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

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

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

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

  // required int32 x = 1;
  bool has_x() const;
  void clear_x();
  static const int kXFieldNumber = 1;
  ::google::protobuf::int32 x() const;
  void set_x(::google::protobuf::int32 value);

  // required int32 y = 2;
  bool has_y() const;
  void clear_y();
  static const int kYFieldNumber = 2;
  ::google::protobuf::int32 y() const;
  void set_y(::google::protobuf::int32 value);

  // optional int32 id = 3;
  bool has_id() const;
  void clear_id();
  static const int kIdFieldNumber = 3;
  ::google::protobuf::int32 id() const;
  void set_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:nm.message.SquareOpen)
 private:
  inline void set_has_x();
  inline void clear_has_x();
  inline void set_has_y();
  inline void clear_has_y();
  inline void set_has_id();
  inline void clear_has_id();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::int32 x_;
  ::google::protobuf::int32 y_;
  ::google::protobuf::int32 id_;
  friend void  protobuf_AddDesc_netmine_2eproto();
  friend void protobuf_AssignDesc_netmine_2eproto();
  friend void protobuf_ShutdownFile_netmine_2eproto();

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

class SquareFlag : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:nm.message.SquareFlag) */ {
 public:
  SquareFlag();
  virtual ~SquareFlag();

  SquareFlag(const SquareFlag& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(SquareFlag* other);

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

  inline SquareFlag* New() const { return New(NULL); }

  SquareFlag* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SquareFlag& from);
  void MergeFrom(const SquareFlag& 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* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SquareFlag* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

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

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

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

  // required int32 x = 1;
  bool has_x() const;
  void clear_x();
  static const int kXFieldNumber = 1;
  ::google::protobuf::int32 x() const;
  void set_x(::google::protobuf::int32 value);

  // required int32 y = 2;
  bool has_y() const;
  void clear_y();
  static const int kYFieldNumber = 2;
  ::google::protobuf::int32 y() const;
  void set_y(::google::protobuf::int32 value);

  // optional int32 id = 3;
  bool has_id() const;
  void clear_id();
  static const int kIdFieldNumber = 3;
  ::google::protobuf::int32 id() const;
  void set_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:nm.message.SquareFlag)
 private:
  inline void set_has_x();
  inline void clear_has_x();
  inline void set_has_y();
  inline void clear_has_y();
  inline void set_has_id();
  inline void clear_has_id();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::int32 x_;
  ::google::protobuf::int32 y_;
  ::google::protobuf::int32 id_;
  friend void  protobuf_AddDesc_netmine_2eproto();
  friend void protobuf_AssignDesc_netmine_2eproto();
  friend void protobuf_ShutdownFile_netmine_2eproto();

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

class Player : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:nm.message.Player) */ {
 public:
  Player();
  virtual ~Player();

  Player(const Player& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(Player* other);

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

  inline Player* New() const { return New(NULL); }

  Player* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Player& from);
  void MergeFrom(const Player& 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* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Player* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

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

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

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

  // required int32 x = 1;
  bool has_x() const;
  void clear_x();
  static const int kXFieldNumber = 1;
  ::google::protobuf::int32 x() const;
  void set_x(::google::protobuf::int32 value);

  // required int32 y = 2;
  bool has_y() const;
  void clear_y();
  static const int kYFieldNumber = 2;
  ::google::protobuf::int32 y() const;
  void set_y(::google::protobuf::int32 value);

  // optional int32 id = 3;
  bool has_id() const;
  void clear_id();
  static const int kIdFieldNumber = 3;
  ::google::protobuf::int32 id() const;
  void set_id(::google::protobuf::int32 value);

  // optional string name = 4;
  bool has_name() const;
  void clear_name();
  static const int kNameFieldNumber = 4;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // @@protoc_insertion_point(class_scope:nm.message.Player)
 private:
  inline void set_has_x();
  inline void clear_has_x();
  inline void set_has_y();
  inline void clear_has_y();
  inline void set_has_id();
  inline void clear_has_id();
  inline void set_has_name();
  inline void clear_has_name();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::int32 x_;
  ::google::protobuf::int32 y_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::int32 id_;
  friend void  protobuf_AddDesc_netmine_2eproto();
  friend void protobuf_AssignDesc_netmine_2eproto();
  friend void protobuf_ShutdownFile_netmine_2eproto();

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

class Welcome : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:nm.message.Welcome) */ {
 public:
  Welcome();
  virtual ~Welcome();

  Welcome(const Welcome& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(Welcome* other);

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

  inline Welcome* New() const { return New(NULL); }

  Welcome* New(::google::protobuf::Arena* arena) const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Welcome& from);
  void MergeFrom(const Welcome& 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* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
    return InternalSerializeWithCachedSizesToArray(false, output);
  }
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Welcome* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

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

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

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

  // required int32 version = 1;
  bool has_version() const;
  void clear_version();
  static const int kVersionFieldNumber = 1;
  ::google::protobuf::int32 version() const;
  void set_version(::google::protobuf::int32 value);

  // required int32 nPlayers = 2;
  bool has_nplayers() const;
  void clear_nplayers();
  static const int kNPlayersFieldNumber = 2;
  ::google::protobuf::int32 nplayers() const;
  void set_nplayers(::google::protobuf::int32 value);

  // repeated .nm.message.Player players = 3;
  int players_size() const;
  void clear_players();
  static const int kPlayersFieldNumber = 3;
  const ::nm::message::Player& players(int index) const;
  ::nm::message::Player* mutable_players(int index);
  ::nm::message::Player* add_players();
  ::google::protobuf::RepeatedPtrField< ::nm::message::Player >*
      mutable_players();
  const ::google::protobuf::RepeatedPtrField< ::nm::message::Player >&
      players() const;

  // @@protoc_insertion_point(class_scope:nm.message.Welcome)
 private:
  inline void set_has_version();
  inline void clear_has_version();
  inline void set_has_nplayers();
  inline void clear_has_nplayers();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::int32 version_;
  ::google::protobuf::int32 nplayers_;
  ::google::protobuf::RepeatedPtrField< ::nm::message::Player > players_;
  friend void  protobuf_AddDesc_netmine_2eproto();
  friend void protobuf_AssignDesc_netmine_2eproto();
  friend void protobuf_ShutdownFile_netmine_2eproto();

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


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

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// MessageWrapper

// required .nm.message.MessageWrapper.Type type = 1;
inline bool MessageWrapper::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MessageWrapper::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MessageWrapper::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MessageWrapper::clear_type() {
  type_ = 1;
  clear_has_type();
}
inline ::nm::message::MessageWrapper_Type MessageWrapper::type() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.type)
  return static_cast< ::nm::message::MessageWrapper_Type >(type_);
}
inline void MessageWrapper::set_type(::nm::message::MessageWrapper_Type value) {
  assert(::nm::message::MessageWrapper_Type_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:nm.message.MessageWrapper.type)
}

// optional .nm.message.CursorMove cursorMove = 2;
inline bool MessageWrapper::has_cursormove() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MessageWrapper::set_has_cursormove() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MessageWrapper::clear_has_cursormove() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MessageWrapper::clear_cursormove() {
  if (cursormove_ != NULL) cursormove_->::nm::message::CursorMove::Clear();
  clear_has_cursormove();
}
inline const ::nm::message::CursorMove& MessageWrapper::cursormove() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.cursorMove)
  return cursormove_ != NULL ? *cursormove_ : *default_instance_->cursormove_;
}
inline ::nm::message::CursorMove* MessageWrapper::mutable_cursormove() {
  set_has_cursormove();
  if (cursormove_ == NULL) {
    cursormove_ = new ::nm::message::CursorMove;
  }
  // @@protoc_insertion_point(field_mutable:nm.message.MessageWrapper.cursorMove)
  return cursormove_;
}
inline ::nm::message::CursorMove* MessageWrapper::release_cursormove() {
  // @@protoc_insertion_point(field_release:nm.message.MessageWrapper.cursorMove)
  clear_has_cursormove();
  ::nm::message::CursorMove* temp = cursormove_;
  cursormove_ = NULL;
  return temp;
}
inline void MessageWrapper::set_allocated_cursormove(::nm::message::CursorMove* cursormove) {
  delete cursormove_;
  cursormove_ = cursormove;
  if (cursormove) {
    set_has_cursormove();
  } else {
    clear_has_cursormove();
  }
  // @@protoc_insertion_point(field_set_allocated:nm.message.MessageWrapper.cursorMove)
}

// optional .nm.message.SquareOpen squareOpen = 3;
inline bool MessageWrapper::has_squareopen() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MessageWrapper::set_has_squareopen() {
  _has_bits_[0] |= 0x00000004u;
}
inline void MessageWrapper::clear_has_squareopen() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void MessageWrapper::clear_squareopen() {
  if (squareopen_ != NULL) squareopen_->::nm::message::SquareOpen::Clear();
  clear_has_squareopen();
}
inline const ::nm::message::SquareOpen& MessageWrapper::squareopen() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.squareOpen)
  return squareopen_ != NULL ? *squareopen_ : *default_instance_->squareopen_;
}
inline ::nm::message::SquareOpen* MessageWrapper::mutable_squareopen() {
  set_has_squareopen();
  if (squareopen_ == NULL) {
    squareopen_ = new ::nm::message::SquareOpen;
  }
  // @@protoc_insertion_point(field_mutable:nm.message.MessageWrapper.squareOpen)
  return squareopen_;
}
inline ::nm::message::SquareOpen* MessageWrapper::release_squareopen() {
  // @@protoc_insertion_point(field_release:nm.message.MessageWrapper.squareOpen)
  clear_has_squareopen();
  ::nm::message::SquareOpen* temp = squareopen_;
  squareopen_ = NULL;
  return temp;
}
inline void MessageWrapper::set_allocated_squareopen(::nm::message::SquareOpen* squareopen) {
  delete squareopen_;
  squareopen_ = squareopen;
  if (squareopen) {
    set_has_squareopen();
  } else {
    clear_has_squareopen();
  }
  // @@protoc_insertion_point(field_set_allocated:nm.message.MessageWrapper.squareOpen)
}

// optional .nm.message.ChunkBytes chunkBytes = 4;
inline bool MessageWrapper::has_chunkbytes() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MessageWrapper::set_has_chunkbytes() {
  _has_bits_[0] |= 0x00000008u;
}
inline void MessageWrapper::clear_has_chunkbytes() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void MessageWrapper::clear_chunkbytes() {
  if (chunkbytes_ != NULL) chunkbytes_->::nm::message::ChunkBytes::Clear();
  clear_has_chunkbytes();
}
inline const ::nm::message::ChunkBytes& MessageWrapper::chunkbytes() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.chunkBytes)
  return chunkbytes_ != NULL ? *chunkbytes_ : *default_instance_->chunkbytes_;
}
inline ::nm::message::ChunkBytes* MessageWrapper::mutable_chunkbytes() {
  set_has_chunkbytes();
  if (chunkbytes_ == NULL) {
    chunkbytes_ = new ::nm::message::ChunkBytes;
  }
  // @@protoc_insertion_point(field_mutable:nm.message.MessageWrapper.chunkBytes)
  return chunkbytes_;
}
inline ::nm::message::ChunkBytes* MessageWrapper::release_chunkbytes() {
  // @@protoc_insertion_point(field_release:nm.message.MessageWrapper.chunkBytes)
  clear_has_chunkbytes();
  ::nm::message::ChunkBytes* temp = chunkbytes_;
  chunkbytes_ = NULL;
  return temp;
}
inline void MessageWrapper::set_allocated_chunkbytes(::nm::message::ChunkBytes* chunkbytes) {
  delete chunkbytes_;
  chunkbytes_ = chunkbytes;
  if (chunkbytes) {
    set_has_chunkbytes();
  } else {
    clear_has_chunkbytes();
  }
  // @@protoc_insertion_point(field_set_allocated:nm.message.MessageWrapper.chunkBytes)
}

// optional .nm.message.SquareFlag squareFlag = 5;
inline bool MessageWrapper::has_squareflag() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void MessageWrapper::set_has_squareflag() {
  _has_bits_[0] |= 0x00000010u;
}
inline void MessageWrapper::clear_has_squareflag() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void MessageWrapper::clear_squareflag() {
  if (squareflag_ != NULL) squareflag_->::nm::message::SquareFlag::Clear();
  clear_has_squareflag();
}
inline const ::nm::message::SquareFlag& MessageWrapper::squareflag() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.squareFlag)
  return squareflag_ != NULL ? *squareflag_ : *default_instance_->squareflag_;
}
inline ::nm::message::SquareFlag* MessageWrapper::mutable_squareflag() {
  set_has_squareflag();
  if (squareflag_ == NULL) {
    squareflag_ = new ::nm::message::SquareFlag;
  }
  // @@protoc_insertion_point(field_mutable:nm.message.MessageWrapper.squareFlag)
  return squareflag_;
}
inline ::nm::message::SquareFlag* MessageWrapper::release_squareflag() {
  // @@protoc_insertion_point(field_release:nm.message.MessageWrapper.squareFlag)
  clear_has_squareflag();
  ::nm::message::SquareFlag* temp = squareflag_;
  squareflag_ = NULL;
  return temp;
}
inline void MessageWrapper::set_allocated_squareflag(::nm::message::SquareFlag* squareflag) {
  delete squareflag_;
  squareflag_ = squareflag;
  if (squareflag) {
    set_has_squareflag();
  } else {
    clear_has_squareflag();
  }
  // @@protoc_insertion_point(field_set_allocated:nm.message.MessageWrapper.squareFlag)
}

// optional .nm.message.Player playerJoin = 6;
inline bool MessageWrapper::has_playerjoin() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void MessageWrapper::set_has_playerjoin() {
  _has_bits_[0] |= 0x00000020u;
}
inline void MessageWrapper::clear_has_playerjoin() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void MessageWrapper::clear_playerjoin() {
  if (playerjoin_ != NULL) playerjoin_->::nm::message::Player::Clear();
  clear_has_playerjoin();
}
inline const ::nm::message::Player& MessageWrapper::playerjoin() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.playerJoin)
  return playerjoin_ != NULL ? *playerjoin_ : *default_instance_->playerjoin_;
}
inline ::nm::message::Player* MessageWrapper::mutable_playerjoin() {
  set_has_playerjoin();
  if (playerjoin_ == NULL) {
    playerjoin_ = new ::nm::message::Player;
  }
  // @@protoc_insertion_point(field_mutable:nm.message.MessageWrapper.playerJoin)
  return playerjoin_;
}
inline ::nm::message::Player* MessageWrapper::release_playerjoin() {
  // @@protoc_insertion_point(field_release:nm.message.MessageWrapper.playerJoin)
  clear_has_playerjoin();
  ::nm::message::Player* temp = playerjoin_;
  playerjoin_ = NULL;
  return temp;
}
inline void MessageWrapper::set_allocated_playerjoin(::nm::message::Player* playerjoin) {
  delete playerjoin_;
  playerjoin_ = playerjoin;
  if (playerjoin) {
    set_has_playerjoin();
  } else {
    clear_has_playerjoin();
  }
  // @@protoc_insertion_point(field_set_allocated:nm.message.MessageWrapper.playerJoin)
}

// optional .nm.message.Player playerQuit = 7;
inline bool MessageWrapper::has_playerquit() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void MessageWrapper::set_has_playerquit() {
  _has_bits_[0] |= 0x00000040u;
}
inline void MessageWrapper::clear_has_playerquit() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void MessageWrapper::clear_playerquit() {
  if (playerquit_ != NULL) playerquit_->::nm::message::Player::Clear();
  clear_has_playerquit();
}
inline const ::nm::message::Player& MessageWrapper::playerquit() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.playerQuit)
  return playerquit_ != NULL ? *playerquit_ : *default_instance_->playerquit_;
}
inline ::nm::message::Player* MessageWrapper::mutable_playerquit() {
  set_has_playerquit();
  if (playerquit_ == NULL) {
    playerquit_ = new ::nm::message::Player;
  }
  // @@protoc_insertion_point(field_mutable:nm.message.MessageWrapper.playerQuit)
  return playerquit_;
}
inline ::nm::message::Player* MessageWrapper::release_playerquit() {
  // @@protoc_insertion_point(field_release:nm.message.MessageWrapper.playerQuit)
  clear_has_playerquit();
  ::nm::message::Player* temp = playerquit_;
  playerquit_ = NULL;
  return temp;
}
inline void MessageWrapper::set_allocated_playerquit(::nm::message::Player* playerquit) {
  delete playerquit_;
  playerquit_ = playerquit;
  if (playerquit) {
    set_has_playerquit();
  } else {
    clear_has_playerquit();
  }
  // @@protoc_insertion_point(field_set_allocated:nm.message.MessageWrapper.playerQuit)
}

// optional .nm.message.Welcome welcome = 8;
inline bool MessageWrapper::has_welcome() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void MessageWrapper::set_has_welcome() {
  _has_bits_[0] |= 0x00000080u;
}
inline void MessageWrapper::clear_has_welcome() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void MessageWrapper::clear_welcome() {
  if (welcome_ != NULL) welcome_->::nm::message::Welcome::Clear();
  clear_has_welcome();
}
inline const ::nm::message::Welcome& MessageWrapper::welcome() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.welcome)
  return welcome_ != NULL ? *welcome_ : *default_instance_->welcome_;
}
inline ::nm::message::Welcome* MessageWrapper::mutable_welcome() {
  set_has_welcome();
  if (welcome_ == NULL) {
    welcome_ = new ::nm::message::Welcome;
  }
  // @@protoc_insertion_point(field_mutable:nm.message.MessageWrapper.welcome)
  return welcome_;
}
inline ::nm::message::Welcome* MessageWrapper::release_welcome() {
  // @@protoc_insertion_point(field_release:nm.message.MessageWrapper.welcome)
  clear_has_welcome();
  ::nm::message::Welcome* temp = welcome_;
  welcome_ = NULL;
  return temp;
}
inline void MessageWrapper::set_allocated_welcome(::nm::message::Welcome* welcome) {
  delete welcome_;
  welcome_ = welcome;
  if (welcome) {
    set_has_welcome();
  } else {
    clear_has_welcome();
  }
  // @@protoc_insertion_point(field_set_allocated:nm.message.MessageWrapper.welcome)
}

// optional .nm.message.ChunkRequest chunkRequest = 9;
inline bool MessageWrapper::has_chunkrequest() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void MessageWrapper::set_has_chunkrequest() {
  _has_bits_[0] |= 0x00000100u;
}
inline void MessageWrapper::clear_has_chunkrequest() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void MessageWrapper::clear_chunkrequest() {
  if (chunkrequest_ != NULL) chunkrequest_->::nm::message::ChunkRequest::Clear();
  clear_has_chunkrequest();
}
inline const ::nm::message::ChunkRequest& MessageWrapper::chunkrequest() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.chunkRequest)
  return chunkrequest_ != NULL ? *chunkrequest_ : *default_instance_->chunkrequest_;
}
inline ::nm::message::ChunkRequest* MessageWrapper::mutable_chunkrequest() {
  set_has_chunkrequest();
  if (chunkrequest_ == NULL) {
    chunkrequest_ = new ::nm::message::ChunkRequest;
  }
  // @@protoc_insertion_point(field_mutable:nm.message.MessageWrapper.chunkRequest)
  return chunkrequest_;
}
inline ::nm::message::ChunkRequest* MessageWrapper::release_chunkrequest() {
  // @@protoc_insertion_point(field_release:nm.message.MessageWrapper.chunkRequest)
  clear_has_chunkrequest();
  ::nm::message::ChunkRequest* temp = chunkrequest_;
  chunkrequest_ = NULL;
  return temp;
}
inline void MessageWrapper::set_allocated_chunkrequest(::nm::message::ChunkRequest* chunkrequest) {
  delete chunkrequest_;
  chunkrequest_ = chunkrequest;
  if (chunkrequest) {
    set_has_chunkrequest();
  } else {
    clear_has_chunkrequest();
  }
  // @@protoc_insertion_point(field_set_allocated:nm.message.MessageWrapper.chunkRequest)
}

// optional .nm.message.ClearAt clearAt = 10;
inline bool MessageWrapper::has_clearat() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void MessageWrapper::set_has_clearat() {
  _has_bits_[0] |= 0x00000200u;
}
inline void MessageWrapper::clear_has_clearat() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void MessageWrapper::clear_clearat() {
  if (clearat_ != NULL) clearat_->::nm::message::ClearAt::Clear();
  clear_has_clearat();
}
inline const ::nm::message::ClearAt& MessageWrapper::clearat() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.clearAt)
  return clearat_ != NULL ? *clearat_ : *default_instance_->clearat_;
}
inline ::nm::message::ClearAt* MessageWrapper::mutable_clearat() {
  set_has_clearat();
  if (clearat_ == NULL) {
    clearat_ = new ::nm::message::ClearAt;
  }
  // @@protoc_insertion_point(field_mutable:nm.message.MessageWrapper.clearAt)
  return clearat_;
}
inline ::nm::message::ClearAt* MessageWrapper::release_clearat() {
  // @@protoc_insertion_point(field_release:nm.message.MessageWrapper.clearAt)
  clear_has_clearat();
  ::nm::message::ClearAt* temp = clearat_;
  clearat_ = NULL;
  return temp;
}
inline void MessageWrapper::set_allocated_clearat(::nm::message::ClearAt* clearat) {
  delete clearat_;
  clearat_ = clearat;
  if (clearat) {
    set_has_clearat();
  } else {
    clear_has_clearat();
  }
  // @@protoc_insertion_point(field_set_allocated:nm.message.MessageWrapper.clearAt)
}

// optional .nm.message.Player player = 11;
inline bool MessageWrapper::has_player() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void MessageWrapper::set_has_player() {
  _has_bits_[0] |= 0x00000400u;
}
inline void MessageWrapper::clear_has_player() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void MessageWrapper::clear_player() {
  if (player_ != NULL) player_->::nm::message::Player::Clear();
  clear_has_player();
}
inline const ::nm::message::Player& MessageWrapper::player() const {
  // @@protoc_insertion_point(field_get:nm.message.MessageWrapper.player)
  return player_ != NULL ? *player_ : *default_instance_->player_;
}
inline ::nm::message::Player* MessageWrapper::mutable_player() {
  set_has_player();
  if (player_ == NULL) {
    player_ = new ::nm::message::Player;
  }
  // @@protoc_insertion_point(field_mutable:nm.message.MessageWrapper.player)
  return player_;
}
inline ::nm::message::Player* MessageWrapper::release_player() {
  // @@protoc_insertion_point(field_release:nm.message.MessageWrapper.player)
  clear_has_player();
  ::nm::message::Player* temp = player_;
  player_ = NULL;
  return temp;
}
inline void MessageWrapper::set_allocated_player(::nm::message::Player* player) {
  delete player_;
  player_ = player;
  if (player) {
    set_has_player();
  } else {
    clear_has_player();
  }
  // @@protoc_insertion_point(field_set_allocated:nm.message.MessageWrapper.player)
}

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

// ClearAt

// required int32 x = 1;
inline bool ClearAt::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ClearAt::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ClearAt::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ClearAt::clear_x() {
  x_ = 0;
  clear_has_x();
}
inline ::google::protobuf::int32 ClearAt::x() const {
  // @@protoc_insertion_point(field_get:nm.message.ClearAt.x)
  return x_;
}
inline void ClearAt::set_x(::google::protobuf::int32 value) {
  set_has_x();
  x_ = value;
  // @@protoc_insertion_point(field_set:nm.message.ClearAt.x)
}

// required int32 y = 2;
inline bool ClearAt::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ClearAt::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ClearAt::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ClearAt::clear_y() {
  y_ = 0;
  clear_has_y();
}
inline ::google::protobuf::int32 ClearAt::y() const {
  // @@protoc_insertion_point(field_get:nm.message.ClearAt.y)
  return y_;
}
inline void ClearAt::set_y(::google::protobuf::int32 value) {
  set_has_y();
  y_ = value;
  // @@protoc_insertion_point(field_set:nm.message.ClearAt.y)
}

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

// ChunkRequest

// required int32 x = 1;
inline bool ChunkRequest::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChunkRequest::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ChunkRequest::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ChunkRequest::clear_x() {
  x_ = 0;
  clear_has_x();
}
inline ::google::protobuf::int32 ChunkRequest::x() const {
  // @@protoc_insertion_point(field_get:nm.message.ChunkRequest.x)
  return x_;
}
inline void ChunkRequest::set_x(::google::protobuf::int32 value) {
  set_has_x();
  x_ = value;
  // @@protoc_insertion_point(field_set:nm.message.ChunkRequest.x)
}

// required int32 y = 2;
inline bool ChunkRequest::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ChunkRequest::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ChunkRequest::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ChunkRequest::clear_y() {
  y_ = 0;
  clear_has_y();
}
inline ::google::protobuf::int32 ChunkRequest::y() const {
  // @@protoc_insertion_point(field_get:nm.message.ChunkRequest.y)
  return y_;
}
inline void ChunkRequest::set_y(::google::protobuf::int32 value) {
  set_has_y();
  y_ = value;
  // @@protoc_insertion_point(field_set:nm.message.ChunkRequest.y)
}

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

// ChunkBytes

// required int32 x = 1;
inline bool ChunkBytes::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChunkBytes::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ChunkBytes::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ChunkBytes::clear_x() {
  x_ = 0;
  clear_has_x();
}
inline ::google::protobuf::int32 ChunkBytes::x() const {
  // @@protoc_insertion_point(field_get:nm.message.ChunkBytes.x)
  return x_;
}
inline void ChunkBytes::set_x(::google::protobuf::int32 value) {
  set_has_x();
  x_ = value;
  // @@protoc_insertion_point(field_set:nm.message.ChunkBytes.x)
}

// required int32 y = 2;
inline bool ChunkBytes::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ChunkBytes::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ChunkBytes::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ChunkBytes::clear_y() {
  y_ = 0;
  clear_has_y();
}
inline ::google::protobuf::int32 ChunkBytes::y() const {
  // @@protoc_insertion_point(field_get:nm.message.ChunkBytes.y)
  return y_;
}
inline void ChunkBytes::set_y(::google::protobuf::int32 value) {
  set_has_y();
  y_ = value;
  // @@protoc_insertion_point(field_set:nm.message.ChunkBytes.y)
}

// required bytes data = 3;
inline bool ChunkBytes::has_data() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ChunkBytes::set_has_data() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ChunkBytes::clear_has_data() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ChunkBytes::clear_data() {
  data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_data();
}
inline const ::std::string& ChunkBytes::data() const {
  // @@protoc_insertion_point(field_get:nm.message.ChunkBytes.data)
  return data_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChunkBytes::set_data(const ::std::string& value) {
  set_has_data();
  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:nm.message.ChunkBytes.data)
}
inline void ChunkBytes::set_data(const char* value) {
  set_has_data();
  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:nm.message.ChunkBytes.data)
}
inline void ChunkBytes::set_data(const void* value, size_t size) {
  set_has_data();
  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:nm.message.ChunkBytes.data)
}
inline ::std::string* ChunkBytes::mutable_data() {
  set_has_data();
  // @@protoc_insertion_point(field_mutable:nm.message.ChunkBytes.data)
  return data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChunkBytes::release_data() {
  // @@protoc_insertion_point(field_release:nm.message.ChunkBytes.data)
  clear_has_data();
  return data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChunkBytes::set_allocated_data(::std::string* data) {
  if (data != NULL) {
    set_has_data();
  } else {
    clear_has_data();
  }
  data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:nm.message.ChunkBytes.data)
}

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

// CursorMove

// required int32 x = 1;
inline bool CursorMove::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CursorMove::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CursorMove::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CursorMove::clear_x() {
  x_ = 0;
  clear_has_x();
}
inline ::google::protobuf::int32 CursorMove::x() const {
  // @@protoc_insertion_point(field_get:nm.message.CursorMove.x)
  return x_;
}
inline void CursorMove::set_x(::google::protobuf::int32 value) {
  set_has_x();
  x_ = value;
  // @@protoc_insertion_point(field_set:nm.message.CursorMove.x)
}

// required int32 y = 2;
inline bool CursorMove::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CursorMove::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CursorMove::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CursorMove::clear_y() {
  y_ = 0;
  clear_has_y();
}
inline ::google::protobuf::int32 CursorMove::y() const {
  // @@protoc_insertion_point(field_get:nm.message.CursorMove.y)
  return y_;
}
inline void CursorMove::set_y(::google::protobuf::int32 value) {
  set_has_y();
  y_ = value;
  // @@protoc_insertion_point(field_set:nm.message.CursorMove.y)
}

// optional int32 id = 3;
inline bool CursorMove::has_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CursorMove::set_has_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CursorMove::clear_has_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CursorMove::clear_id() {
  id_ = 0;
  clear_has_id();
}
inline ::google::protobuf::int32 CursorMove::id() const {
  // @@protoc_insertion_point(field_get:nm.message.CursorMove.id)
  return id_;
}
inline void CursorMove::set_id(::google::protobuf::int32 value) {
  set_has_id();
  id_ = value;
  // @@protoc_insertion_point(field_set:nm.message.CursorMove.id)
}

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

// SquareOpen

// required int32 x = 1;
inline bool SquareOpen::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SquareOpen::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SquareOpen::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SquareOpen::clear_x() {
  x_ = 0;
  clear_has_x();
}
inline ::google::protobuf::int32 SquareOpen::x() const {
  // @@protoc_insertion_point(field_get:nm.message.SquareOpen.x)
  return x_;
}
inline void SquareOpen::set_x(::google::protobuf::int32 value) {
  set_has_x();
  x_ = value;
  // @@protoc_insertion_point(field_set:nm.message.SquareOpen.x)
}

// required int32 y = 2;
inline bool SquareOpen::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SquareOpen::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SquareOpen::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SquareOpen::clear_y() {
  y_ = 0;
  clear_has_y();
}
inline ::google::protobuf::int32 SquareOpen::y() const {
  // @@protoc_insertion_point(field_get:nm.message.SquareOpen.y)
  return y_;
}
inline void SquareOpen::set_y(::google::protobuf::int32 value) {
  set_has_y();
  y_ = value;
  // @@protoc_insertion_point(field_set:nm.message.SquareOpen.y)
}

// optional int32 id = 3;
inline bool SquareOpen::has_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SquareOpen::set_has_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SquareOpen::clear_has_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SquareOpen::clear_id() {
  id_ = 0;
  clear_has_id();
}
inline ::google::protobuf::int32 SquareOpen::id() const {
  // @@protoc_insertion_point(field_get:nm.message.SquareOpen.id)
  return id_;
}
inline void SquareOpen::set_id(::google::protobuf::int32 value) {
  set_has_id();
  id_ = value;
  // @@protoc_insertion_point(field_set:nm.message.SquareOpen.id)
}

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

// SquareFlag

// required int32 x = 1;
inline bool SquareFlag::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SquareFlag::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SquareFlag::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SquareFlag::clear_x() {
  x_ = 0;
  clear_has_x();
}
inline ::google::protobuf::int32 SquareFlag::x() const {
  // @@protoc_insertion_point(field_get:nm.message.SquareFlag.x)
  return x_;
}
inline void SquareFlag::set_x(::google::protobuf::int32 value) {
  set_has_x();
  x_ = value;
  // @@protoc_insertion_point(field_set:nm.message.SquareFlag.x)
}

// required int32 y = 2;
inline bool SquareFlag::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SquareFlag::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SquareFlag::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SquareFlag::clear_y() {
  y_ = 0;
  clear_has_y();
}
inline ::google::protobuf::int32 SquareFlag::y() const {
  // @@protoc_insertion_point(field_get:nm.message.SquareFlag.y)
  return y_;
}
inline void SquareFlag::set_y(::google::protobuf::int32 value) {
  set_has_y();
  y_ = value;
  // @@protoc_insertion_point(field_set:nm.message.SquareFlag.y)
}

// optional int32 id = 3;
inline bool SquareFlag::has_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SquareFlag::set_has_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SquareFlag::clear_has_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SquareFlag::clear_id() {
  id_ = 0;
  clear_has_id();
}
inline ::google::protobuf::int32 SquareFlag::id() const {
  // @@protoc_insertion_point(field_get:nm.message.SquareFlag.id)
  return id_;
}
inline void SquareFlag::set_id(::google::protobuf::int32 value) {
  set_has_id();
  id_ = value;
  // @@protoc_insertion_point(field_set:nm.message.SquareFlag.id)
}

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

// Player

// required int32 x = 1;
inline bool Player::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Player::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Player::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Player::clear_x() {
  x_ = 0;
  clear_has_x();
}
inline ::google::protobuf::int32 Player::x() const {
  // @@protoc_insertion_point(field_get:nm.message.Player.x)
  return x_;
}
inline void Player::set_x(::google::protobuf::int32 value) {
  set_has_x();
  x_ = value;
  // @@protoc_insertion_point(field_set:nm.message.Player.x)
}

// required int32 y = 2;
inline bool Player::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Player::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Player::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Player::clear_y() {
  y_ = 0;
  clear_has_y();
}
inline ::google::protobuf::int32 Player::y() const {
  // @@protoc_insertion_point(field_get:nm.message.Player.y)
  return y_;
}
inline void Player::set_y(::google::protobuf::int32 value) {
  set_has_y();
  y_ = value;
  // @@protoc_insertion_point(field_set:nm.message.Player.y)
}

// optional int32 id = 3;
inline bool Player::has_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Player::set_has_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Player::clear_has_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Player::clear_id() {
  id_ = 0;
  clear_has_id();
}
inline ::google::protobuf::int32 Player::id() const {
  // @@protoc_insertion_point(field_get:nm.message.Player.id)
  return id_;
}
inline void Player::set_id(::google::protobuf::int32 value) {
  set_has_id();
  id_ = value;
  // @@protoc_insertion_point(field_set:nm.message.Player.id)
}

// optional string name = 4;
inline bool Player::has_name() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Player::set_has_name() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Player::clear_has_name() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Player::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& Player::name() const {
  // @@protoc_insertion_point(field_get:nm.message.Player.name)
  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Player::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:nm.message.Player.name)
}
inline void Player::set_name(const char* value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:nm.message.Player.name)
}
inline void Player::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:nm.message.Player.name)
}
inline ::std::string* Player::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:nm.message.Player.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Player::release_name() {
  // @@protoc_insertion_point(field_release:nm.message.Player.name)
  clear_has_name();
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Player::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:nm.message.Player.name)
}

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

// Welcome

// required int32 version = 1;
inline bool Welcome::has_version() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Welcome::set_has_version() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Welcome::clear_has_version() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Welcome::clear_version() {
  version_ = 0;
  clear_has_version();
}
inline ::google::protobuf::int32 Welcome::version() const {
  // @@protoc_insertion_point(field_get:nm.message.Welcome.version)
  return version_;
}
inline void Welcome::set_version(::google::protobuf::int32 value) {
  set_has_version();
  version_ = value;
  // @@protoc_insertion_point(field_set:nm.message.Welcome.version)
}

// required int32 nPlayers = 2;
inline bool Welcome::has_nplayers() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Welcome::set_has_nplayers() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Welcome::clear_has_nplayers() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Welcome::clear_nplayers() {
  nplayers_ = 0;
  clear_has_nplayers();
}
inline ::google::protobuf::int32 Welcome::nplayers() const {
  // @@protoc_insertion_point(field_get:nm.message.Welcome.nPlayers)
  return nplayers_;
}
inline void Welcome::set_nplayers(::google::protobuf::int32 value) {
  set_has_nplayers();
  nplayers_ = value;
  // @@protoc_insertion_point(field_set:nm.message.Welcome.nPlayers)
}

// repeated .nm.message.Player players = 3;
inline int Welcome::players_size() const {
  return players_.size();
}
inline void Welcome::clear_players() {
  players_.Clear();
}
inline const ::nm::message::Player& Welcome::players(int index) const {
  // @@protoc_insertion_point(field_get:nm.message.Welcome.players)
  return players_.Get(index);
}
inline ::nm::message::Player* Welcome::mutable_players(int index) {
  // @@protoc_insertion_point(field_mutable:nm.message.Welcome.players)
  return players_.Mutable(index);
}
inline ::nm::message::Player* Welcome::add_players() {
  // @@protoc_insertion_point(field_add:nm.message.Welcome.players)
  return players_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::nm::message::Player >*
Welcome::mutable_players() {
  // @@protoc_insertion_point(field_mutable_list:nm.message.Welcome.players)
  return &players_;
}
inline const ::google::protobuf::RepeatedPtrField< ::nm::message::Player >&
Welcome::players() const {
  // @@protoc_insertion_point(field_list:nm.message.Welcome.players)
  return players_;
}

#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace message
}  // namespace nm

#ifndef SWIG
namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::nm::message::MessageWrapper_Type> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::nm::message::MessageWrapper_Type>() {
  return ::nm::message::MessageWrapper_Type_descriptor();
}

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

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_netmine_2eproto__INCLUDED