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

#ifndef GOOGLE_PROTOBUF_INCLUDED_remote_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_remote_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#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 3019004 < 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/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_bases.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_remote_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_remote_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[15]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_remote_2eproto;
namespace remote {
class Answer;
struct AnswerDefaultTypeInternal;
extern AnswerDefaultTypeInternal _Answer_default_instance_;
class CSRep;
struct CSRepDefaultTypeInternal;
extern CSRepDefaultTypeInternal _CSRep_default_instance_;
class CSReq;
struct CSReqDefaultTypeInternal;
extern CSReqDefaultTypeInternal _CSReq_default_instance_;
class CSRobot;
struct CSRobotDefaultTypeInternal;
extern CSRobotDefaultTypeInternal _CSRobot_default_instance_;
class CSSigin;
struct CSSiginDefaultTypeInternal;
extern CSSiginDefaultTypeInternal _CSSigin_default_instance_;
class Candidate;
struct CandidateDefaultTypeInternal;
extern CandidateDefaultTypeInternal _Candidate_default_instance_;
class Leave;
struct LeaveDefaultTypeInternal;
extern LeaveDefaultTypeInternal _Leave_default_instance_;
class Offer;
struct OfferDefaultTypeInternal;
extern OfferDefaultTypeInternal _Offer_default_instance_;
class Robot;
struct RobotDefaultTypeInternal;
extern RobotDefaultTypeInternal _Robot_default_instance_;
class SCAddRobot;
struct SCAddRobotDefaultTypeInternal;
extern SCAddRobotDefaultTypeInternal _SCAddRobot_default_instance_;
class SCDelRobot;
struct SCDelRobotDefaultTypeInternal;
extern SCDelRobotDefaultTypeInternal _SCDelRobot_default_instance_;
class SCRep;
struct SCRepDefaultTypeInternal;
extern SCRepDefaultTypeInternal _SCRep_default_instance_;
class SCReq;
struct SCReqDefaultTypeInternal;
extern SCReqDefaultTypeInternal _SCReq_default_instance_;
class SCRobot;
struct SCRobotDefaultTypeInternal;
extern SCRobotDefaultTypeInternal _SCRobot_default_instance_;
class SCSigin;
struct SCSiginDefaultTypeInternal;
extern SCSiginDefaultTypeInternal _SCSigin_default_instance_;
}  // namespace remote
PROTOBUF_NAMESPACE_OPEN
template<> ::remote::Answer* Arena::CreateMaybeMessage<::remote::Answer>(Arena*);
template<> ::remote::CSRep* Arena::CreateMaybeMessage<::remote::CSRep>(Arena*);
template<> ::remote::CSReq* Arena::CreateMaybeMessage<::remote::CSReq>(Arena*);
template<> ::remote::CSRobot* Arena::CreateMaybeMessage<::remote::CSRobot>(Arena*);
template<> ::remote::CSSigin* Arena::CreateMaybeMessage<::remote::CSSigin>(Arena*);
template<> ::remote::Candidate* Arena::CreateMaybeMessage<::remote::Candidate>(Arena*);
template<> ::remote::Leave* Arena::CreateMaybeMessage<::remote::Leave>(Arena*);
template<> ::remote::Offer* Arena::CreateMaybeMessage<::remote::Offer>(Arena*);
template<> ::remote::Robot* Arena::CreateMaybeMessage<::remote::Robot>(Arena*);
template<> ::remote::SCAddRobot* Arena::CreateMaybeMessage<::remote::SCAddRobot>(Arena*);
template<> ::remote::SCDelRobot* Arena::CreateMaybeMessage<::remote::SCDelRobot>(Arena*);
template<> ::remote::SCRep* Arena::CreateMaybeMessage<::remote::SCRep>(Arena*);
template<> ::remote::SCReq* Arena::CreateMaybeMessage<::remote::SCReq>(Arena*);
template<> ::remote::SCRobot* Arena::CreateMaybeMessage<::remote::SCRobot>(Arena*);
template<> ::remote::SCSigin* Arena::CreateMaybeMessage<::remote::SCSigin>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace remote {

enum cs_message : int {
  cs_none = 0,
  cs_req = 2001,
  cs_rep = 2002,
  cs_offer = 2004,
  cs_answer = 2005,
  cs_candidate = 2006,
  cs_leave = 2007,
  cs_keepAlive = 2008,
  cs_sigin = 2009,
  cs_robot = 2010,
  cs_closeVideo = 2011,
  cs_state = 2014,
  cs_message_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  cs_message_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool cs_message_IsValid(int value);
constexpr cs_message cs_message_MIN = cs_none;
constexpr cs_message cs_message_MAX = cs_state;
constexpr int cs_message_ARRAYSIZE = cs_message_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* cs_message_descriptor();
template<typename T>
inline const std::string& cs_message_Name(T enum_t_value) {
  static_assert(::std::is_same<T, cs_message>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function cs_message_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    cs_message_descriptor(), enum_t_value);
}
inline bool cs_message_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, cs_message* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<cs_message>(
    cs_message_descriptor(), name, value);
}
enum sc_message : int {
  sc_none = 0,
  sc_req = 4001,
  sc_rep = 4002,
  sc_offer = 4004,
  sc_answer = 4005,
  sc_candidate = 4006,
  sc_sigin = 4007,
  sc_robot = 4008,
  sc_NotifyReq = 4009,
  sc_NotifyRep = 4010,
  sc_NotifyAnswer = 4011,
  sc_NotifyOffer = 4012,
  sc_NotifyCandidate = 4013,
  sc_NotifyLeave = 4014,
  sc_NotifyAdd = 4016,
  sc_NotifyDel = 4017,
  sc_NotifyCloseVideo = 4018,
  sc_NotifyState = 4025,
  sc_message_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  sc_message_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool sc_message_IsValid(int value);
constexpr sc_message sc_message_MIN = sc_none;
constexpr sc_message sc_message_MAX = sc_NotifyState;
constexpr int sc_message_ARRAYSIZE = sc_message_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* sc_message_descriptor();
template<typename T>
inline const std::string& sc_message_Name(T enum_t_value) {
  static_assert(::std::is_same<T, sc_message>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function sc_message_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    sc_message_descriptor(), enum_t_value);
}
inline bool sc_message_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, sc_message* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<sc_message>(
    sc_message_descriptor(), name, value);
}
// ===================================================================

class Offer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.Offer) */ {
 public:
  inline Offer() : Offer(nullptr) {}
  ~Offer() override;
  explicit constexpr Offer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Offer(const Offer& from);
  Offer(Offer&& from) noexcept
    : Offer() {
    *this = ::std::move(from);
  }

  inline Offer& operator=(const Offer& from) {
    CopyFrom(from);
    return *this;
  }
  inline Offer& operator=(Offer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Offer& default_instance() {
    return *internal_default_instance();
  }
  static inline const Offer* internal_default_instance() {
    return reinterpret_cast<const Offer*>(
               &_Offer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Offer& a, Offer& b) {
    a.Swap(&b);
  }
  inline void Swap(Offer* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Offer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Offer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Offer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Offer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Offer& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Offer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.Offer";
  }
  protected:
  explicit Offer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTypeFieldNumber = 3,
    kSdpFieldNumber = 4,
    kIndexFieldNumber = 1,
    kPeerFieldNumber = 2,
  };
  // string type = 3;
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // string sdp = 4;
  void clear_sdp();
  const std::string& sdp() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sdp(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sdp();
  PROTOBUF_NODISCARD std::string* release_sdp();
  void set_allocated_sdp(std::string* sdp);
  private:
  const std::string& _internal_sdp() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdp(const std::string& value);
  std::string* _internal_mutable_sdp();
  public:

  // int32 index = 1;
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // int32 peer = 2;
  void clear_peer();
  int32_t peer() const;
  void set_peer(int32_t value);
  private:
  int32_t _internal_peer() const;
  void _internal_set_peer(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.Offer)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdp_;
  int32_t index_;
  int32_t peer_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class Answer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.Answer) */ {
 public:
  inline Answer() : Answer(nullptr) {}
  ~Answer() override;
  explicit constexpr Answer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Answer(const Answer& from);
  Answer(Answer&& from) noexcept
    : Answer() {
    *this = ::std::move(from);
  }

  inline Answer& operator=(const Answer& from) {
    CopyFrom(from);
    return *this;
  }
  inline Answer& operator=(Answer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Answer& default_instance() {
    return *internal_default_instance();
  }
  static inline const Answer* internal_default_instance() {
    return reinterpret_cast<const Answer*>(
               &_Answer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Answer& a, Answer& b) {
    a.Swap(&b);
  }
  inline void Swap(Answer* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Answer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Answer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Answer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Answer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Answer& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Answer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.Answer";
  }
  protected:
  explicit Answer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTypeFieldNumber = 3,
    kSdpFieldNumber = 4,
    kIndexFieldNumber = 1,
    kPeerFieldNumber = 2,
  };
  // string type = 3;
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // string sdp = 4;
  void clear_sdp();
  const std::string& sdp() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sdp(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sdp();
  PROTOBUF_NODISCARD std::string* release_sdp();
  void set_allocated_sdp(std::string* sdp);
  private:
  const std::string& _internal_sdp() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdp(const std::string& value);
  std::string* _internal_mutable_sdp();
  public:

  // int32 index = 1;
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // int32 peer = 2;
  void clear_peer();
  int32_t peer() const;
  void set_peer(int32_t value);
  private:
  int32_t _internal_peer() const;
  void _internal_set_peer(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.Answer)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdp_;
  int32_t index_;
  int32_t peer_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class Candidate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.Candidate) */ {
 public:
  inline Candidate() : Candidate(nullptr) {}
  ~Candidate() override;
  explicit constexpr Candidate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Candidate(const Candidate& from);
  Candidate(Candidate&& from) noexcept
    : Candidate() {
    *this = ::std::move(from);
  }

  inline Candidate& operator=(const Candidate& from) {
    CopyFrom(from);
    return *this;
  }
  inline Candidate& operator=(Candidate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Candidate& default_instance() {
    return *internal_default_instance();
  }
  static inline const Candidate* internal_default_instance() {
    return reinterpret_cast<const Candidate*>(
               &_Candidate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Candidate& a, Candidate& b) {
    a.Swap(&b);
  }
  inline void Swap(Candidate* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Candidate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Candidate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Candidate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Candidate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Candidate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Candidate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.Candidate";
  }
  protected:
  explicit Candidate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTypeFieldNumber = 3,
    kCandidateFieldNumber = 4,
    kSdpMidFieldNumber = 6,
    kIndexFieldNumber = 1,
    kPeerFieldNumber = 2,
    kSdpMLineIndexFieldNumber = 5,
    kEgotypeFieldNumber = 7,
  };
  // string type = 3;
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // string candidate = 4;
  void clear_candidate();
  const std::string& candidate() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_candidate(ArgT0&& arg0, ArgT... args);
  std::string* mutable_candidate();
  PROTOBUF_NODISCARD std::string* release_candidate();
  void set_allocated_candidate(std::string* candidate);
  private:
  const std::string& _internal_candidate() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_candidate(const std::string& value);
  std::string* _internal_mutable_candidate();
  public:

  // string sdpMid = 6;
  void clear_sdpmid();
  const std::string& sdpmid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sdpmid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sdpmid();
  PROTOBUF_NODISCARD std::string* release_sdpmid();
  void set_allocated_sdpmid(std::string* sdpmid);
  private:
  const std::string& _internal_sdpmid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdpmid(const std::string& value);
  std::string* _internal_mutable_sdpmid();
  public:

  // int32 index = 1;
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // int32 peer = 2;
  void clear_peer();
  int32_t peer() const;
  void set_peer(int32_t value);
  private:
  int32_t _internal_peer() const;
  void _internal_set_peer(int32_t value);
  public:

  // int32 sdpMLineIndex = 5;
  void clear_sdpmlineindex();
  int32_t sdpmlineindex() const;
  void set_sdpmlineindex(int32_t value);
  private:
  int32_t _internal_sdpmlineindex() const;
  void _internal_set_sdpmlineindex(int32_t value);
  public:

  // int32 egotype = 7;
  void clear_egotype();
  int32_t egotype() const;
  void set_egotype(int32_t value);
  private:
  int32_t _internal_egotype() const;
  void _internal_set_egotype(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.Candidate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr candidate_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdpmid_;
  int32_t index_;
  int32_t peer_;
  int32_t sdpmlineindex_;
  int32_t egotype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class CSReq final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.CSReq) */ {
 public:
  inline CSReq() : CSReq(nullptr) {}
  ~CSReq() override;
  explicit constexpr CSReq(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSReq(const CSReq& from);
  CSReq(CSReq&& from) noexcept
    : CSReq() {
    *this = ::std::move(from);
  }

  inline CSReq& operator=(const CSReq& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSReq& operator=(CSReq&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSReq& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSReq* internal_default_instance() {
    return reinterpret_cast<const CSReq*>(
               &_CSReq_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(CSReq& a, CSReq& b) {
    a.Swap(&b);
  }
  inline void Swap(CSReq* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSReq* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CSReq* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSReq>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSReq& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CSReq& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSReq* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.CSReq";
  }
  protected:
  explicit CSReq(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kPeerFieldNumber = 1,
    kIndexFieldNumber = 2,
    kEgotypeFieldNumber = 3,
  };
  // int32 peer = 1;
  void clear_peer();
  int32_t peer() const;
  void set_peer(int32_t value);
  private:
  int32_t _internal_peer() const;
  void _internal_set_peer(int32_t value);
  public:

  // int32 index = 2;
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // int32 egotype = 3;
  void clear_egotype();
  int32_t egotype() const;
  void set_egotype(int32_t value);
  private:
  int32_t _internal_egotype() const;
  void _internal_set_egotype(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.CSReq)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int32_t peer_;
  int32_t index_;
  int32_t egotype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class SCReq final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.SCReq) */ {
 public:
  inline SCReq() : SCReq(nullptr) {}
  ~SCReq() override;
  explicit constexpr SCReq(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SCReq(const SCReq& from);
  SCReq(SCReq&& from) noexcept
    : SCReq() {
    *this = ::std::move(from);
  }

  inline SCReq& operator=(const SCReq& from) {
    CopyFrom(from);
    return *this;
  }
  inline SCReq& operator=(SCReq&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SCReq& default_instance() {
    return *internal_default_instance();
  }
  static inline const SCReq* internal_default_instance() {
    return reinterpret_cast<const SCReq*>(
               &_SCReq_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(SCReq& a, SCReq& b) {
    a.Swap(&b);
  }
  inline void Swap(SCReq* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SCReq* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SCReq* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SCReq>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SCReq& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SCReq& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SCReq* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.SCReq";
  }
  protected:
  explicit SCReq(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDescFieldNumber = 1,
    kPeerFieldNumber = 2,
    kEgotypeFieldNumber = 3,
  };
  // int32 desc = 1;
  void clear_desc();
  int32_t desc() const;
  void set_desc(int32_t value);
  private:
  int32_t _internal_desc() const;
  void _internal_set_desc(int32_t value);
  public:

  // int32 peer = 2;
  void clear_peer();
  int32_t peer() const;
  void set_peer(int32_t value);
  private:
  int32_t _internal_peer() const;
  void _internal_set_peer(int32_t value);
  public:

  // int32 egotype = 3;
  void clear_egotype();
  int32_t egotype() const;
  void set_egotype(int32_t value);
  private:
  int32_t _internal_egotype() const;
  void _internal_set_egotype(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.SCReq)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int32_t desc_;
  int32_t peer_;
  int32_t egotype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class CSRep final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.CSRep) */ {
 public:
  inline CSRep() : CSRep(nullptr) {}
  ~CSRep() override;
  explicit constexpr CSRep(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSRep(const CSRep& from);
  CSRep(CSRep&& from) noexcept
    : CSRep() {
    *this = ::std::move(from);
  }

  inline CSRep& operator=(const CSRep& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSRep& operator=(CSRep&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSRep& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSRep* internal_default_instance() {
    return reinterpret_cast<const CSRep*>(
               &_CSRep_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(CSRep& a, CSRep& b) {
    a.Swap(&b);
  }
  inline void Swap(CSRep* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSRep* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CSRep* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSRep>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSRep& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CSRep& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSRep* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.CSRep";
  }
  protected:
  explicit CSRep(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDescFieldNumber = 1,
    kPeerFieldNumber = 2,
    kIndexFieldNumber = 3,
    kEgotypeFieldNumber = 4,
  };
  // int32 desc = 1;
  void clear_desc();
  int32_t desc() const;
  void set_desc(int32_t value);
  private:
  int32_t _internal_desc() const;
  void _internal_set_desc(int32_t value);
  public:

  // int32 peer = 2;
  void clear_peer();
  int32_t peer() const;
  void set_peer(int32_t value);
  private:
  int32_t _internal_peer() const;
  void _internal_set_peer(int32_t value);
  public:

  // int32 index = 3;
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // int32 egotype = 4;
  void clear_egotype();
  int32_t egotype() const;
  void set_egotype(int32_t value);
  private:
  int32_t _internal_egotype() const;
  void _internal_set_egotype(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.CSRep)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int32_t desc_;
  int32_t peer_;
  int32_t index_;
  int32_t egotype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class SCRep final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.SCRep) */ {
 public:
  inline SCRep() : SCRep(nullptr) {}
  ~SCRep() override;
  explicit constexpr SCRep(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SCRep(const SCRep& from);
  SCRep(SCRep&& from) noexcept
    : SCRep() {
    *this = ::std::move(from);
  }

  inline SCRep& operator=(const SCRep& from) {
    CopyFrom(from);
    return *this;
  }
  inline SCRep& operator=(SCRep&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SCRep& default_instance() {
    return *internal_default_instance();
  }
  static inline const SCRep* internal_default_instance() {
    return reinterpret_cast<const SCRep*>(
               &_SCRep_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(SCRep& a, SCRep& b) {
    a.Swap(&b);
  }
  inline void Swap(SCRep* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SCRep* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SCRep* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SCRep>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SCRep& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SCRep& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SCRep* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.SCRep";
  }
  protected:
  explicit SCRep(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDescFieldNumber = 1,
    kIndexFieldNumber = 2,
    kEgotypeFieldNumber = 3,
    kPeerFieldNumber = 4,
  };
  // int32 desc = 1;
  void clear_desc();
  int32_t desc() const;
  void set_desc(int32_t value);
  private:
  int32_t _internal_desc() const;
  void _internal_set_desc(int32_t value);
  public:

  // int32 index = 2;
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // int32 egotype = 3;
  void clear_egotype();
  int32_t egotype() const;
  void set_egotype(int32_t value);
  private:
  int32_t _internal_egotype() const;
  void _internal_set_egotype(int32_t value);
  public:

  // int32 peer = 4;
  void clear_peer();
  int32_t peer() const;
  void set_peer(int32_t value);
  private:
  int32_t _internal_peer() const;
  void _internal_set_peer(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.SCRep)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int32_t desc_;
  int32_t index_;
  int32_t egotype_;
  int32_t peer_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class CSSigin final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.CSSigin) */ {
 public:
  inline CSSigin() : CSSigin(nullptr) {}
  ~CSSigin() override;
  explicit constexpr CSSigin(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSSigin(const CSSigin& from);
  CSSigin(CSSigin&& from) noexcept
    : CSSigin() {
    *this = ::std::move(from);
  }

  inline CSSigin& operator=(const CSSigin& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSSigin& operator=(CSSigin&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSSigin& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSSigin* internal_default_instance() {
    return reinterpret_cast<const CSSigin*>(
               &_CSSigin_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(CSSigin& a, CSSigin& b) {
    a.Swap(&b);
  }
  inline void Swap(CSSigin* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSSigin* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CSSigin* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSSigin>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSSigin& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CSSigin& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSSigin* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.CSSigin";
  }
  protected:
  explicit CSSigin(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kAccountFieldNumber = 1,
    kNameFieldNumber = 3,
    kPassFieldNumber = 4,
    kTypeFieldNumber = 2,
  };
  // string account = 1;
  void clear_account();
  const std::string& account() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_account(ArgT0&& arg0, ArgT... args);
  std::string* mutable_account();
  PROTOBUF_NODISCARD std::string* release_account();
  void set_allocated_account(std::string* account);
  private:
  const std::string& _internal_account() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_account(const std::string& value);
  std::string* _internal_mutable_account();
  public:

  // string name = 3;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string pass = 4;
  void clear_pass();
  const std::string& pass() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pass(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pass();
  PROTOBUF_NODISCARD std::string* release_pass();
  void set_allocated_pass(std::string* pass);
  private:
  const std::string& _internal_pass() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pass(const std::string& value);
  std::string* _internal_mutable_pass();
  public:

  // int32 type = 2;
  void clear_type();
  int32_t type() const;
  void set_type(int32_t value);
  private:
  int32_t _internal_type() const;
  void _internal_set_type(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.CSSigin)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr account_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pass_;
  int32_t type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class SCSigin final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.SCSigin) */ {
 public:
  inline SCSigin() : SCSigin(nullptr) {}
  ~SCSigin() override;
  explicit constexpr SCSigin(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SCSigin(const SCSigin& from);
  SCSigin(SCSigin&& from) noexcept
    : SCSigin() {
    *this = ::std::move(from);
  }

  inline SCSigin& operator=(const SCSigin& from) {
    CopyFrom(from);
    return *this;
  }
  inline SCSigin& operator=(SCSigin&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SCSigin& default_instance() {
    return *internal_default_instance();
  }
  static inline const SCSigin* internal_default_instance() {
    return reinterpret_cast<const SCSigin*>(
               &_SCSigin_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(SCSigin& a, SCSigin& b) {
    a.Swap(&b);
  }
  inline void Swap(SCSigin* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SCSigin* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SCSigin* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SCSigin>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SCSigin& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SCSigin& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SCSigin* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.SCSigin";
  }
  protected:
  explicit SCSigin(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kNameFieldNumber = 3,
    kRetFieldNumber = 1,
    kUidFieldNumber = 2,
  };
  // string name = 3;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // bool ret = 1;
  void clear_ret();
  bool ret() const;
  void set_ret(bool value);
  private:
  bool _internal_ret() const;
  void _internal_set_ret(bool value);
  public:

  // int32 uid = 2;
  void clear_uid();
  int32_t uid() const;
  void set_uid(int32_t value);
  private:
  int32_t _internal_uid() const;
  void _internal_set_uid(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.SCSigin)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  bool ret_;
  int32_t uid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class Robot final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.Robot) */ {
 public:
  inline Robot() : Robot(nullptr) {}
  ~Robot() override;
  explicit constexpr Robot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Robot(const Robot& from);
  Robot(Robot&& from) noexcept
    : Robot() {
    *this = ::std::move(from);
  }

  inline Robot& operator=(const Robot& from) {
    CopyFrom(from);
    return *this;
  }
  inline Robot& operator=(Robot&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Robot& default_instance() {
    return *internal_default_instance();
  }
  static inline const Robot* internal_default_instance() {
    return reinterpret_cast<const Robot*>(
               &_Robot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(Robot& a, Robot& b) {
    a.Swap(&b);
  }
  inline void Swap(Robot* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Robot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Robot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Robot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Robot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Robot& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Robot* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.Robot";
  }
  protected:
  explicit Robot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kNameFieldNumber = 2,
    kRidFieldNumber = 1,
    kTypeFieldNumber = 3,
    kStateFieldNumber = 4,
  };
  // string name = 2;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // int32 rid = 1;
  void clear_rid();
  int32_t rid() const;
  void set_rid(int32_t value);
  private:
  int32_t _internal_rid() const;
  void _internal_set_rid(int32_t value);
  public:

  // int32 type = 3;
  void clear_type();
  int32_t type() const;
  void set_type(int32_t value);
  private:
  int32_t _internal_type() const;
  void _internal_set_type(int32_t value);
  public:

  // int32 state = 4;
  void clear_state();
  int32_t state() const;
  void set_state(int32_t value);
  private:
  int32_t _internal_state() const;
  void _internal_set_state(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.Robot)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  int32_t rid_;
  int32_t type_;
  int32_t state_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class SCAddRobot final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.SCAddRobot) */ {
 public:
  inline SCAddRobot() : SCAddRobot(nullptr) {}
  ~SCAddRobot() override;
  explicit constexpr SCAddRobot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SCAddRobot(const SCAddRobot& from);
  SCAddRobot(SCAddRobot&& from) noexcept
    : SCAddRobot() {
    *this = ::std::move(from);
  }

  inline SCAddRobot& operator=(const SCAddRobot& from) {
    CopyFrom(from);
    return *this;
  }
  inline SCAddRobot& operator=(SCAddRobot&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SCAddRobot& default_instance() {
    return *internal_default_instance();
  }
  static inline const SCAddRobot* internal_default_instance() {
    return reinterpret_cast<const SCAddRobot*>(
               &_SCAddRobot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(SCAddRobot& a, SCAddRobot& b) {
    a.Swap(&b);
  }
  inline void Swap(SCAddRobot* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SCAddRobot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SCAddRobot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SCAddRobot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SCAddRobot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SCAddRobot& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SCAddRobot* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.SCAddRobot";
  }
  protected:
  explicit SCAddRobot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kRobotFieldNumber = 1,
  };
  // .remote.Robot robot = 1;
  bool has_robot() const;
  private:
  bool _internal_has_robot() const;
  public:
  void clear_robot();
  const ::remote::Robot& robot() const;
  PROTOBUF_NODISCARD ::remote::Robot* release_robot();
  ::remote::Robot* mutable_robot();
  void set_allocated_robot(::remote::Robot* robot);
  private:
  const ::remote::Robot& _internal_robot() const;
  ::remote::Robot* _internal_mutable_robot();
  public:
  void unsafe_arena_set_allocated_robot(
      ::remote::Robot* robot);
  ::remote::Robot* unsafe_arena_release_robot();

  // @@protoc_insertion_point(class_scope:remote.SCAddRobot)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::remote::Robot* robot_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class SCDelRobot final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.SCDelRobot) */ {
 public:
  inline SCDelRobot() : SCDelRobot(nullptr) {}
  ~SCDelRobot() override;
  explicit constexpr SCDelRobot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SCDelRobot(const SCDelRobot& from);
  SCDelRobot(SCDelRobot&& from) noexcept
    : SCDelRobot() {
    *this = ::std::move(from);
  }

  inline SCDelRobot& operator=(const SCDelRobot& from) {
    CopyFrom(from);
    return *this;
  }
  inline SCDelRobot& operator=(SCDelRobot&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SCDelRobot& default_instance() {
    return *internal_default_instance();
  }
  static inline const SCDelRobot* internal_default_instance() {
    return reinterpret_cast<const SCDelRobot*>(
               &_SCDelRobot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(SCDelRobot& a, SCDelRobot& b) {
    a.Swap(&b);
  }
  inline void Swap(SCDelRobot* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SCDelRobot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SCDelRobot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SCDelRobot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SCDelRobot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SCDelRobot& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SCDelRobot* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.SCDelRobot";
  }
  protected:
  explicit SCDelRobot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kPeerFieldNumber = 1,
    kEgotypeFieldNumber = 2,
  };
  // int32 peer = 1;
  void clear_peer();
  int32_t peer() const;
  void set_peer(int32_t value);
  private:
  int32_t _internal_peer() const;
  void _internal_set_peer(int32_t value);
  public:

  // int32 egotype = 2;
  void clear_egotype();
  int32_t egotype() const;
  void set_egotype(int32_t value);
  private:
  int32_t _internal_egotype() const;
  void _internal_set_egotype(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.SCDelRobot)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int32_t peer_;
  int32_t egotype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class CSRobot final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:remote.CSRobot) */ {
 public:
  inline CSRobot() : CSRobot(nullptr) {}
  explicit constexpr CSRobot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSRobot(const CSRobot& from);
  CSRobot(CSRobot&& from) noexcept
    : CSRobot() {
    *this = ::std::move(from);
  }

  inline CSRobot& operator=(const CSRobot& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSRobot& operator=(CSRobot&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSRobot& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSRobot* internal_default_instance() {
    return reinterpret_cast<const CSRobot*>(
               &_CSRobot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(CSRobot& a, CSRobot& b) {
    a.Swap(&b);
  }
  inline void Swap(CSRobot* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSRobot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CSRobot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSRobot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CSRobot& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CSRobot& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.CSRobot";
  }
  protected:
  explicit CSRobot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  // @@protoc_insertion_point(class_scope:remote.CSRobot)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class SCRobot final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.SCRobot) */ {
 public:
  inline SCRobot() : SCRobot(nullptr) {}
  ~SCRobot() override;
  explicit constexpr SCRobot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SCRobot(const SCRobot& from);
  SCRobot(SCRobot&& from) noexcept
    : SCRobot() {
    *this = ::std::move(from);
  }

  inline SCRobot& operator=(const SCRobot& from) {
    CopyFrom(from);
    return *this;
  }
  inline SCRobot& operator=(SCRobot&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SCRobot& default_instance() {
    return *internal_default_instance();
  }
  static inline const SCRobot* internal_default_instance() {
    return reinterpret_cast<const SCRobot*>(
               &_SCRobot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(SCRobot& a, SCRobot& b) {
    a.Swap(&b);
  }
  inline void Swap(SCRobot* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SCRobot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SCRobot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SCRobot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SCRobot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SCRobot& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SCRobot* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.SCRobot";
  }
  protected:
  explicit SCRobot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kRobotFieldNumber = 1,
  };
  // repeated .remote.Robot robot = 1;
  int robot_size() const;
  private:
  int _internal_robot_size() const;
  public:
  void clear_robot();
  ::remote::Robot* mutable_robot(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::remote::Robot >*
      mutable_robot();
  private:
  const ::remote::Robot& _internal_robot(int index) const;
  ::remote::Robot* _internal_add_robot();
  public:
  const ::remote::Robot& robot(int index) const;
  ::remote::Robot* add_robot();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::remote::Robot >&
      robot() const;

  // @@protoc_insertion_point(class_scope:remote.SCRobot)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::remote::Robot > robot_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// -------------------------------------------------------------------

class Leave final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:remote.Leave) */ {
 public:
  inline Leave() : Leave(nullptr) {}
  ~Leave() override;
  explicit constexpr Leave(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Leave(const Leave& from);
  Leave(Leave&& from) noexcept
    : Leave() {
    *this = ::std::move(from);
  }

  inline Leave& operator=(const Leave& from) {
    CopyFrom(from);
    return *this;
  }
  inline Leave& operator=(Leave&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Leave& default_instance() {
    return *internal_default_instance();
  }
  static inline const Leave* internal_default_instance() {
    return reinterpret_cast<const Leave*>(
               &_Leave_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(Leave& a, Leave& b) {
    a.Swap(&b);
  }
  inline void Swap(Leave* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Leave* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Leave* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Leave>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Leave& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Leave& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Leave* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "remote.Leave";
  }
  protected:
  explicit Leave(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kPeerFieldNumber = 1,
    kEgotypeFieldNumber = 2,
  };
  // int32 peer = 1;
  void clear_peer();
  int32_t peer() const;
  void set_peer(int32_t value);
  private:
  int32_t _internal_peer() const;
  void _internal_set_peer(int32_t value);
  public:

  // int32 egotype = 2;
  void clear_egotype();
  int32_t egotype() const;
  void set_egotype(int32_t value);
  private:
  int32_t _internal_egotype() const;
  void _internal_set_egotype(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:remote.Leave)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int32_t peer_;
  int32_t egotype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_remote_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Offer

// int32 index = 1;
inline void Offer::clear_index() {
  index_ = 0;
}
inline int32_t Offer::_internal_index() const {
  return index_;
}
inline int32_t Offer::index() const {
  // @@protoc_insertion_point(field_get:remote.Offer.index)
  return _internal_index();
}
inline void Offer::_internal_set_index(int32_t value) {
  
  index_ = value;
}
inline void Offer::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:remote.Offer.index)
}

// int32 peer = 2;
inline void Offer::clear_peer() {
  peer_ = 0;
}
inline int32_t Offer::_internal_peer() const {
  return peer_;
}
inline int32_t Offer::peer() const {
  // @@protoc_insertion_point(field_get:remote.Offer.peer)
  return _internal_peer();
}
inline void Offer::_internal_set_peer(int32_t value) {
  
  peer_ = value;
}
inline void Offer::set_peer(int32_t value) {
  _internal_set_peer(value);
  // @@protoc_insertion_point(field_set:remote.Offer.peer)
}

// string type = 3;
inline void Offer::clear_type() {
  type_.ClearToEmpty();
}
inline const std::string& Offer::type() const {
  // @@protoc_insertion_point(field_get:remote.Offer.type)
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Offer::set_type(ArgT0&& arg0, ArgT... args) {
 
 type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.Offer.type)
}
inline std::string* Offer::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:remote.Offer.type)
  return _s;
}
inline const std::string& Offer::_internal_type() const {
  return type_.Get();
}
inline void Offer::_internal_set_type(const std::string& value) {
  
  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Offer::_internal_mutable_type() {
  
  return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Offer::release_type() {
  // @@protoc_insertion_point(field_release:remote.Offer.type)
  return type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Offer::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.Offer.type)
}

// string sdp = 4;
inline void Offer::clear_sdp() {
  sdp_.ClearToEmpty();
}
inline const std::string& Offer::sdp() const {
  // @@protoc_insertion_point(field_get:remote.Offer.sdp)
  return _internal_sdp();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Offer::set_sdp(ArgT0&& arg0, ArgT... args) {
 
 sdp_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.Offer.sdp)
}
inline std::string* Offer::mutable_sdp() {
  std::string* _s = _internal_mutable_sdp();
  // @@protoc_insertion_point(field_mutable:remote.Offer.sdp)
  return _s;
}
inline const std::string& Offer::_internal_sdp() const {
  return sdp_.Get();
}
inline void Offer::_internal_set_sdp(const std::string& value) {
  
  sdp_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Offer::_internal_mutable_sdp() {
  
  return sdp_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Offer::release_sdp() {
  // @@protoc_insertion_point(field_release:remote.Offer.sdp)
  return sdp_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Offer::set_allocated_sdp(std::string* sdp) {
  if (sdp != nullptr) {
    
  } else {
    
  }
  sdp_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sdp,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (sdp_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    sdp_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.Offer.sdp)
}

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

// Answer

// int32 index = 1;
inline void Answer::clear_index() {
  index_ = 0;
}
inline int32_t Answer::_internal_index() const {
  return index_;
}
inline int32_t Answer::index() const {
  // @@protoc_insertion_point(field_get:remote.Answer.index)
  return _internal_index();
}
inline void Answer::_internal_set_index(int32_t value) {
  
  index_ = value;
}
inline void Answer::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:remote.Answer.index)
}

// int32 peer = 2;
inline void Answer::clear_peer() {
  peer_ = 0;
}
inline int32_t Answer::_internal_peer() const {
  return peer_;
}
inline int32_t Answer::peer() const {
  // @@protoc_insertion_point(field_get:remote.Answer.peer)
  return _internal_peer();
}
inline void Answer::_internal_set_peer(int32_t value) {
  
  peer_ = value;
}
inline void Answer::set_peer(int32_t value) {
  _internal_set_peer(value);
  // @@protoc_insertion_point(field_set:remote.Answer.peer)
}

// string type = 3;
inline void Answer::clear_type() {
  type_.ClearToEmpty();
}
inline const std::string& Answer::type() const {
  // @@protoc_insertion_point(field_get:remote.Answer.type)
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Answer::set_type(ArgT0&& arg0, ArgT... args) {
 
 type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.Answer.type)
}
inline std::string* Answer::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:remote.Answer.type)
  return _s;
}
inline const std::string& Answer::_internal_type() const {
  return type_.Get();
}
inline void Answer::_internal_set_type(const std::string& value) {
  
  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Answer::_internal_mutable_type() {
  
  return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Answer::release_type() {
  // @@protoc_insertion_point(field_release:remote.Answer.type)
  return type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Answer::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.Answer.type)
}

// string sdp = 4;
inline void Answer::clear_sdp() {
  sdp_.ClearToEmpty();
}
inline const std::string& Answer::sdp() const {
  // @@protoc_insertion_point(field_get:remote.Answer.sdp)
  return _internal_sdp();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Answer::set_sdp(ArgT0&& arg0, ArgT... args) {
 
 sdp_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.Answer.sdp)
}
inline std::string* Answer::mutable_sdp() {
  std::string* _s = _internal_mutable_sdp();
  // @@protoc_insertion_point(field_mutable:remote.Answer.sdp)
  return _s;
}
inline const std::string& Answer::_internal_sdp() const {
  return sdp_.Get();
}
inline void Answer::_internal_set_sdp(const std::string& value) {
  
  sdp_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Answer::_internal_mutable_sdp() {
  
  return sdp_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Answer::release_sdp() {
  // @@protoc_insertion_point(field_release:remote.Answer.sdp)
  return sdp_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Answer::set_allocated_sdp(std::string* sdp) {
  if (sdp != nullptr) {
    
  } else {
    
  }
  sdp_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sdp,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (sdp_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    sdp_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.Answer.sdp)
}

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

// Candidate

// int32 index = 1;
inline void Candidate::clear_index() {
  index_ = 0;
}
inline int32_t Candidate::_internal_index() const {
  return index_;
}
inline int32_t Candidate::index() const {
  // @@protoc_insertion_point(field_get:remote.Candidate.index)
  return _internal_index();
}
inline void Candidate::_internal_set_index(int32_t value) {
  
  index_ = value;
}
inline void Candidate::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:remote.Candidate.index)
}

// int32 peer = 2;
inline void Candidate::clear_peer() {
  peer_ = 0;
}
inline int32_t Candidate::_internal_peer() const {
  return peer_;
}
inline int32_t Candidate::peer() const {
  // @@protoc_insertion_point(field_get:remote.Candidate.peer)
  return _internal_peer();
}
inline void Candidate::_internal_set_peer(int32_t value) {
  
  peer_ = value;
}
inline void Candidate::set_peer(int32_t value) {
  _internal_set_peer(value);
  // @@protoc_insertion_point(field_set:remote.Candidate.peer)
}

// string type = 3;
inline void Candidate::clear_type() {
  type_.ClearToEmpty();
}
inline const std::string& Candidate::type() const {
  // @@protoc_insertion_point(field_get:remote.Candidate.type)
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Candidate::set_type(ArgT0&& arg0, ArgT... args) {
 
 type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.Candidate.type)
}
inline std::string* Candidate::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:remote.Candidate.type)
  return _s;
}
inline const std::string& Candidate::_internal_type() const {
  return type_.Get();
}
inline void Candidate::_internal_set_type(const std::string& value) {
  
  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Candidate::_internal_mutable_type() {
  
  return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Candidate::release_type() {
  // @@protoc_insertion_point(field_release:remote.Candidate.type)
  return type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Candidate::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.Candidate.type)
}

// string candidate = 4;
inline void Candidate::clear_candidate() {
  candidate_.ClearToEmpty();
}
inline const std::string& Candidate::candidate() const {
  // @@protoc_insertion_point(field_get:remote.Candidate.candidate)
  return _internal_candidate();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Candidate::set_candidate(ArgT0&& arg0, ArgT... args) {
 
 candidate_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.Candidate.candidate)
}
inline std::string* Candidate::mutable_candidate() {
  std::string* _s = _internal_mutable_candidate();
  // @@protoc_insertion_point(field_mutable:remote.Candidate.candidate)
  return _s;
}
inline const std::string& Candidate::_internal_candidate() const {
  return candidate_.Get();
}
inline void Candidate::_internal_set_candidate(const std::string& value) {
  
  candidate_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Candidate::_internal_mutable_candidate() {
  
  return candidate_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Candidate::release_candidate() {
  // @@protoc_insertion_point(field_release:remote.Candidate.candidate)
  return candidate_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Candidate::set_allocated_candidate(std::string* candidate) {
  if (candidate != nullptr) {
    
  } else {
    
  }
  candidate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), candidate,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (candidate_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    candidate_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.Candidate.candidate)
}

// int32 sdpMLineIndex = 5;
inline void Candidate::clear_sdpmlineindex() {
  sdpmlineindex_ = 0;
}
inline int32_t Candidate::_internal_sdpmlineindex() const {
  return sdpmlineindex_;
}
inline int32_t Candidate::sdpmlineindex() const {
  // @@protoc_insertion_point(field_get:remote.Candidate.sdpMLineIndex)
  return _internal_sdpmlineindex();
}
inline void Candidate::_internal_set_sdpmlineindex(int32_t value) {
  
  sdpmlineindex_ = value;
}
inline void Candidate::set_sdpmlineindex(int32_t value) {
  _internal_set_sdpmlineindex(value);
  // @@protoc_insertion_point(field_set:remote.Candidate.sdpMLineIndex)
}

// string sdpMid = 6;
inline void Candidate::clear_sdpmid() {
  sdpmid_.ClearToEmpty();
}
inline const std::string& Candidate::sdpmid() const {
  // @@protoc_insertion_point(field_get:remote.Candidate.sdpMid)
  return _internal_sdpmid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Candidate::set_sdpmid(ArgT0&& arg0, ArgT... args) {
 
 sdpmid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.Candidate.sdpMid)
}
inline std::string* Candidate::mutable_sdpmid() {
  std::string* _s = _internal_mutable_sdpmid();
  // @@protoc_insertion_point(field_mutable:remote.Candidate.sdpMid)
  return _s;
}
inline const std::string& Candidate::_internal_sdpmid() const {
  return sdpmid_.Get();
}
inline void Candidate::_internal_set_sdpmid(const std::string& value) {
  
  sdpmid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Candidate::_internal_mutable_sdpmid() {
  
  return sdpmid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Candidate::release_sdpmid() {
  // @@protoc_insertion_point(field_release:remote.Candidate.sdpMid)
  return sdpmid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Candidate::set_allocated_sdpmid(std::string* sdpmid) {
  if (sdpmid != nullptr) {
    
  } else {
    
  }
  sdpmid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sdpmid,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (sdpmid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    sdpmid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.Candidate.sdpMid)
}

// int32 egotype = 7;
inline void Candidate::clear_egotype() {
  egotype_ = 0;
}
inline int32_t Candidate::_internal_egotype() const {
  return egotype_;
}
inline int32_t Candidate::egotype() const {
  // @@protoc_insertion_point(field_get:remote.Candidate.egotype)
  return _internal_egotype();
}
inline void Candidate::_internal_set_egotype(int32_t value) {
  
  egotype_ = value;
}
inline void Candidate::set_egotype(int32_t value) {
  _internal_set_egotype(value);
  // @@protoc_insertion_point(field_set:remote.Candidate.egotype)
}

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

// CSReq

// int32 peer = 1;
inline void CSReq::clear_peer() {
  peer_ = 0;
}
inline int32_t CSReq::_internal_peer() const {
  return peer_;
}
inline int32_t CSReq::peer() const {
  // @@protoc_insertion_point(field_get:remote.CSReq.peer)
  return _internal_peer();
}
inline void CSReq::_internal_set_peer(int32_t value) {
  
  peer_ = value;
}
inline void CSReq::set_peer(int32_t value) {
  _internal_set_peer(value);
  // @@protoc_insertion_point(field_set:remote.CSReq.peer)
}

// int32 index = 2;
inline void CSReq::clear_index() {
  index_ = 0;
}
inline int32_t CSReq::_internal_index() const {
  return index_;
}
inline int32_t CSReq::index() const {
  // @@protoc_insertion_point(field_get:remote.CSReq.index)
  return _internal_index();
}
inline void CSReq::_internal_set_index(int32_t value) {
  
  index_ = value;
}
inline void CSReq::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:remote.CSReq.index)
}

// int32 egotype = 3;
inline void CSReq::clear_egotype() {
  egotype_ = 0;
}
inline int32_t CSReq::_internal_egotype() const {
  return egotype_;
}
inline int32_t CSReq::egotype() const {
  // @@protoc_insertion_point(field_get:remote.CSReq.egotype)
  return _internal_egotype();
}
inline void CSReq::_internal_set_egotype(int32_t value) {
  
  egotype_ = value;
}
inline void CSReq::set_egotype(int32_t value) {
  _internal_set_egotype(value);
  // @@protoc_insertion_point(field_set:remote.CSReq.egotype)
}

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

// SCReq

// int32 desc = 1;
inline void SCReq::clear_desc() {
  desc_ = 0;
}
inline int32_t SCReq::_internal_desc() const {
  return desc_;
}
inline int32_t SCReq::desc() const {
  // @@protoc_insertion_point(field_get:remote.SCReq.desc)
  return _internal_desc();
}
inline void SCReq::_internal_set_desc(int32_t value) {
  
  desc_ = value;
}
inline void SCReq::set_desc(int32_t value) {
  _internal_set_desc(value);
  // @@protoc_insertion_point(field_set:remote.SCReq.desc)
}

// int32 peer = 2;
inline void SCReq::clear_peer() {
  peer_ = 0;
}
inline int32_t SCReq::_internal_peer() const {
  return peer_;
}
inline int32_t SCReq::peer() const {
  // @@protoc_insertion_point(field_get:remote.SCReq.peer)
  return _internal_peer();
}
inline void SCReq::_internal_set_peer(int32_t value) {
  
  peer_ = value;
}
inline void SCReq::set_peer(int32_t value) {
  _internal_set_peer(value);
  // @@protoc_insertion_point(field_set:remote.SCReq.peer)
}

// int32 egotype = 3;
inline void SCReq::clear_egotype() {
  egotype_ = 0;
}
inline int32_t SCReq::_internal_egotype() const {
  return egotype_;
}
inline int32_t SCReq::egotype() const {
  // @@protoc_insertion_point(field_get:remote.SCReq.egotype)
  return _internal_egotype();
}
inline void SCReq::_internal_set_egotype(int32_t value) {
  
  egotype_ = value;
}
inline void SCReq::set_egotype(int32_t value) {
  _internal_set_egotype(value);
  // @@protoc_insertion_point(field_set:remote.SCReq.egotype)
}

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

// CSRep

// int32 desc = 1;
inline void CSRep::clear_desc() {
  desc_ = 0;
}
inline int32_t CSRep::_internal_desc() const {
  return desc_;
}
inline int32_t CSRep::desc() const {
  // @@protoc_insertion_point(field_get:remote.CSRep.desc)
  return _internal_desc();
}
inline void CSRep::_internal_set_desc(int32_t value) {
  
  desc_ = value;
}
inline void CSRep::set_desc(int32_t value) {
  _internal_set_desc(value);
  // @@protoc_insertion_point(field_set:remote.CSRep.desc)
}

// int32 peer = 2;
inline void CSRep::clear_peer() {
  peer_ = 0;
}
inline int32_t CSRep::_internal_peer() const {
  return peer_;
}
inline int32_t CSRep::peer() const {
  // @@protoc_insertion_point(field_get:remote.CSRep.peer)
  return _internal_peer();
}
inline void CSRep::_internal_set_peer(int32_t value) {
  
  peer_ = value;
}
inline void CSRep::set_peer(int32_t value) {
  _internal_set_peer(value);
  // @@protoc_insertion_point(field_set:remote.CSRep.peer)
}

// int32 index = 3;
inline void CSRep::clear_index() {
  index_ = 0;
}
inline int32_t CSRep::_internal_index() const {
  return index_;
}
inline int32_t CSRep::index() const {
  // @@protoc_insertion_point(field_get:remote.CSRep.index)
  return _internal_index();
}
inline void CSRep::_internal_set_index(int32_t value) {
  
  index_ = value;
}
inline void CSRep::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:remote.CSRep.index)
}

// int32 egotype = 4;
inline void CSRep::clear_egotype() {
  egotype_ = 0;
}
inline int32_t CSRep::_internal_egotype() const {
  return egotype_;
}
inline int32_t CSRep::egotype() const {
  // @@protoc_insertion_point(field_get:remote.CSRep.egotype)
  return _internal_egotype();
}
inline void CSRep::_internal_set_egotype(int32_t value) {
  
  egotype_ = value;
}
inline void CSRep::set_egotype(int32_t value) {
  _internal_set_egotype(value);
  // @@protoc_insertion_point(field_set:remote.CSRep.egotype)
}

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

// SCRep

// int32 desc = 1;
inline void SCRep::clear_desc() {
  desc_ = 0;
}
inline int32_t SCRep::_internal_desc() const {
  return desc_;
}
inline int32_t SCRep::desc() const {
  // @@protoc_insertion_point(field_get:remote.SCRep.desc)
  return _internal_desc();
}
inline void SCRep::_internal_set_desc(int32_t value) {
  
  desc_ = value;
}
inline void SCRep::set_desc(int32_t value) {
  _internal_set_desc(value);
  // @@protoc_insertion_point(field_set:remote.SCRep.desc)
}

// int32 index = 2;
inline void SCRep::clear_index() {
  index_ = 0;
}
inline int32_t SCRep::_internal_index() const {
  return index_;
}
inline int32_t SCRep::index() const {
  // @@protoc_insertion_point(field_get:remote.SCRep.index)
  return _internal_index();
}
inline void SCRep::_internal_set_index(int32_t value) {
  
  index_ = value;
}
inline void SCRep::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:remote.SCRep.index)
}

// int32 egotype = 3;
inline void SCRep::clear_egotype() {
  egotype_ = 0;
}
inline int32_t SCRep::_internal_egotype() const {
  return egotype_;
}
inline int32_t SCRep::egotype() const {
  // @@protoc_insertion_point(field_get:remote.SCRep.egotype)
  return _internal_egotype();
}
inline void SCRep::_internal_set_egotype(int32_t value) {
  
  egotype_ = value;
}
inline void SCRep::set_egotype(int32_t value) {
  _internal_set_egotype(value);
  // @@protoc_insertion_point(field_set:remote.SCRep.egotype)
}

// int32 peer = 4;
inline void SCRep::clear_peer() {
  peer_ = 0;
}
inline int32_t SCRep::_internal_peer() const {
  return peer_;
}
inline int32_t SCRep::peer() const {
  // @@protoc_insertion_point(field_get:remote.SCRep.peer)
  return _internal_peer();
}
inline void SCRep::_internal_set_peer(int32_t value) {
  
  peer_ = value;
}
inline void SCRep::set_peer(int32_t value) {
  _internal_set_peer(value);
  // @@protoc_insertion_point(field_set:remote.SCRep.peer)
}

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

// CSSigin

// string account = 1;
inline void CSSigin::clear_account() {
  account_.ClearToEmpty();
}
inline const std::string& CSSigin::account() const {
  // @@protoc_insertion_point(field_get:remote.CSSigin.account)
  return _internal_account();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSSigin::set_account(ArgT0&& arg0, ArgT... args) {
 
 account_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.CSSigin.account)
}
inline std::string* CSSigin::mutable_account() {
  std::string* _s = _internal_mutable_account();
  // @@protoc_insertion_point(field_mutable:remote.CSSigin.account)
  return _s;
}
inline const std::string& CSSigin::_internal_account() const {
  return account_.Get();
}
inline void CSSigin::_internal_set_account(const std::string& value) {
  
  account_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CSSigin::_internal_mutable_account() {
  
  return account_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CSSigin::release_account() {
  // @@protoc_insertion_point(field_release:remote.CSSigin.account)
  return account_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void CSSigin::set_allocated_account(std::string* account) {
  if (account != nullptr) {
    
  } else {
    
  }
  account_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), account,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (account_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    account_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.CSSigin.account)
}

// int32 type = 2;
inline void CSSigin::clear_type() {
  type_ = 0;
}
inline int32_t CSSigin::_internal_type() const {
  return type_;
}
inline int32_t CSSigin::type() const {
  // @@protoc_insertion_point(field_get:remote.CSSigin.type)
  return _internal_type();
}
inline void CSSigin::_internal_set_type(int32_t value) {
  
  type_ = value;
}
inline void CSSigin::set_type(int32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:remote.CSSigin.type)
}

// string name = 3;
inline void CSSigin::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& CSSigin::name() const {
  // @@protoc_insertion_point(field_get:remote.CSSigin.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSSigin::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.CSSigin.name)
}
inline std::string* CSSigin::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:remote.CSSigin.name)
  return _s;
}
inline const std::string& CSSigin::_internal_name() const {
  return name_.Get();
}
inline void CSSigin::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CSSigin::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CSSigin::release_name() {
  // @@protoc_insertion_point(field_release:remote.CSSigin.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void CSSigin::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.CSSigin.name)
}

// string pass = 4;
inline void CSSigin::clear_pass() {
  pass_.ClearToEmpty();
}
inline const std::string& CSSigin::pass() const {
  // @@protoc_insertion_point(field_get:remote.CSSigin.pass)
  return _internal_pass();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSSigin::set_pass(ArgT0&& arg0, ArgT... args) {
 
 pass_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.CSSigin.pass)
}
inline std::string* CSSigin::mutable_pass() {
  std::string* _s = _internal_mutable_pass();
  // @@protoc_insertion_point(field_mutable:remote.CSSigin.pass)
  return _s;
}
inline const std::string& CSSigin::_internal_pass() const {
  return pass_.Get();
}
inline void CSSigin::_internal_set_pass(const std::string& value) {
  
  pass_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CSSigin::_internal_mutable_pass() {
  
  return pass_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CSSigin::release_pass() {
  // @@protoc_insertion_point(field_release:remote.CSSigin.pass)
  return pass_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void CSSigin::set_allocated_pass(std::string* pass) {
  if (pass != nullptr) {
    
  } else {
    
  }
  pass_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pass,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (pass_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    pass_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.CSSigin.pass)
}

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

// SCSigin

// bool ret = 1;
inline void SCSigin::clear_ret() {
  ret_ = false;
}
inline bool SCSigin::_internal_ret() const {
  return ret_;
}
inline bool SCSigin::ret() const {
  // @@protoc_insertion_point(field_get:remote.SCSigin.ret)
  return _internal_ret();
}
inline void SCSigin::_internal_set_ret(bool value) {
  
  ret_ = value;
}
inline void SCSigin::set_ret(bool value) {
  _internal_set_ret(value);
  // @@protoc_insertion_point(field_set:remote.SCSigin.ret)
}

// int32 uid = 2;
inline void SCSigin::clear_uid() {
  uid_ = 0;
}
inline int32_t SCSigin::_internal_uid() const {
  return uid_;
}
inline int32_t SCSigin::uid() const {
  // @@protoc_insertion_point(field_get:remote.SCSigin.uid)
  return _internal_uid();
}
inline void SCSigin::_internal_set_uid(int32_t value) {
  
  uid_ = value;
}
inline void SCSigin::set_uid(int32_t value) {
  _internal_set_uid(value);
  // @@protoc_insertion_point(field_set:remote.SCSigin.uid)
}

// string name = 3;
inline void SCSigin::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& SCSigin::name() const {
  // @@protoc_insertion_point(field_get:remote.SCSigin.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SCSigin::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.SCSigin.name)
}
inline std::string* SCSigin::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:remote.SCSigin.name)
  return _s;
}
inline const std::string& SCSigin::_internal_name() const {
  return name_.Get();
}
inline void SCSigin::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SCSigin::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SCSigin::release_name() {
  // @@protoc_insertion_point(field_release:remote.SCSigin.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SCSigin::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.SCSigin.name)
}

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

// Robot

// int32 rid = 1;
inline void Robot::clear_rid() {
  rid_ = 0;
}
inline int32_t Robot::_internal_rid() const {
  return rid_;
}
inline int32_t Robot::rid() const {
  // @@protoc_insertion_point(field_get:remote.Robot.rid)
  return _internal_rid();
}
inline void Robot::_internal_set_rid(int32_t value) {
  
  rid_ = value;
}
inline void Robot::set_rid(int32_t value) {
  _internal_set_rid(value);
  // @@protoc_insertion_point(field_set:remote.Robot.rid)
}

// string name = 2;
inline void Robot::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& Robot::name() const {
  // @@protoc_insertion_point(field_get:remote.Robot.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Robot::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:remote.Robot.name)
}
inline std::string* Robot::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:remote.Robot.name)
  return _s;
}
inline const std::string& Robot::_internal_name() const {
  return name_.Get();
}
inline void Robot::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Robot::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Robot::release_name() {
  // @@protoc_insertion_point(field_release:remote.Robot.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Robot::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:remote.Robot.name)
}

// int32 type = 3;
inline void Robot::clear_type() {
  type_ = 0;
}
inline int32_t Robot::_internal_type() const {
  return type_;
}
inline int32_t Robot::type() const {
  // @@protoc_insertion_point(field_get:remote.Robot.type)
  return _internal_type();
}
inline void Robot::_internal_set_type(int32_t value) {
  
  type_ = value;
}
inline void Robot::set_type(int32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:remote.Robot.type)
}

// int32 state = 4;
inline void Robot::clear_state() {
  state_ = 0;
}
inline int32_t Robot::_internal_state() const {
  return state_;
}
inline int32_t Robot::state() const {
  // @@protoc_insertion_point(field_get:remote.Robot.state)
  return _internal_state();
}
inline void Robot::_internal_set_state(int32_t value) {
  
  state_ = value;
}
inline void Robot::set_state(int32_t value) {
  _internal_set_state(value);
  // @@protoc_insertion_point(field_set:remote.Robot.state)
}

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

// SCAddRobot

// .remote.Robot robot = 1;
inline bool SCAddRobot::_internal_has_robot() const {
  return this != internal_default_instance() && robot_ != nullptr;
}
inline bool SCAddRobot::has_robot() const {
  return _internal_has_robot();
}
inline void SCAddRobot::clear_robot() {
  if (GetArenaForAllocation() == nullptr && robot_ != nullptr) {
    delete robot_;
  }
  robot_ = nullptr;
}
inline const ::remote::Robot& SCAddRobot::_internal_robot() const {
  const ::remote::Robot* p = robot_;
  return p != nullptr ? *p : reinterpret_cast<const ::remote::Robot&>(
      ::remote::_Robot_default_instance_);
}
inline const ::remote::Robot& SCAddRobot::robot() const {
  // @@protoc_insertion_point(field_get:remote.SCAddRobot.robot)
  return _internal_robot();
}
inline void SCAddRobot::unsafe_arena_set_allocated_robot(
    ::remote::Robot* robot) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(robot_);
  }
  robot_ = robot;
  if (robot) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:remote.SCAddRobot.robot)
}
inline ::remote::Robot* SCAddRobot::release_robot() {
  
  ::remote::Robot* temp = robot_;
  robot_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::remote::Robot* SCAddRobot::unsafe_arena_release_robot() {
  // @@protoc_insertion_point(field_release:remote.SCAddRobot.robot)
  
  ::remote::Robot* temp = robot_;
  robot_ = nullptr;
  return temp;
}
inline ::remote::Robot* SCAddRobot::_internal_mutable_robot() {
  
  if (robot_ == nullptr) {
    auto* p = CreateMaybeMessage<::remote::Robot>(GetArenaForAllocation());
    robot_ = p;
  }
  return robot_;
}
inline ::remote::Robot* SCAddRobot::mutable_robot() {
  ::remote::Robot* _msg = _internal_mutable_robot();
  // @@protoc_insertion_point(field_mutable:remote.SCAddRobot.robot)
  return _msg;
}
inline void SCAddRobot::set_allocated_robot(::remote::Robot* robot) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete robot_;
  }
  if (robot) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::remote::Robot>::GetOwningArena(robot);
    if (message_arena != submessage_arena) {
      robot = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, robot, submessage_arena);
    }
    
  } else {
    
  }
  robot_ = robot;
  // @@protoc_insertion_point(field_set_allocated:remote.SCAddRobot.robot)
}

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

// SCDelRobot

// int32 peer = 1;
inline void SCDelRobot::clear_peer() {
  peer_ = 0;
}
inline int32_t SCDelRobot::_internal_peer() const {
  return peer_;
}
inline int32_t SCDelRobot::peer() const {
  // @@protoc_insertion_point(field_get:remote.SCDelRobot.peer)
  return _internal_peer();
}
inline void SCDelRobot::_internal_set_peer(int32_t value) {
  
  peer_ = value;
}
inline void SCDelRobot::set_peer(int32_t value) {
  _internal_set_peer(value);
  // @@protoc_insertion_point(field_set:remote.SCDelRobot.peer)
}

// int32 egotype = 2;
inline void SCDelRobot::clear_egotype() {
  egotype_ = 0;
}
inline int32_t SCDelRobot::_internal_egotype() const {
  return egotype_;
}
inline int32_t SCDelRobot::egotype() const {
  // @@protoc_insertion_point(field_get:remote.SCDelRobot.egotype)
  return _internal_egotype();
}
inline void SCDelRobot::_internal_set_egotype(int32_t value) {
  
  egotype_ = value;
}
inline void SCDelRobot::set_egotype(int32_t value) {
  _internal_set_egotype(value);
  // @@protoc_insertion_point(field_set:remote.SCDelRobot.egotype)
}

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

// CSRobot

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

// SCRobot

// repeated .remote.Robot robot = 1;
inline int SCRobot::_internal_robot_size() const {
  return robot_.size();
}
inline int SCRobot::robot_size() const {
  return _internal_robot_size();
}
inline void SCRobot::clear_robot() {
  robot_.Clear();
}
inline ::remote::Robot* SCRobot::mutable_robot(int index) {
  // @@protoc_insertion_point(field_mutable:remote.SCRobot.robot)
  return robot_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::remote::Robot >*
SCRobot::mutable_robot() {
  // @@protoc_insertion_point(field_mutable_list:remote.SCRobot.robot)
  return &robot_;
}
inline const ::remote::Robot& SCRobot::_internal_robot(int index) const {
  return robot_.Get(index);
}
inline const ::remote::Robot& SCRobot::robot(int index) const {
  // @@protoc_insertion_point(field_get:remote.SCRobot.robot)
  return _internal_robot(index);
}
inline ::remote::Robot* SCRobot::_internal_add_robot() {
  return robot_.Add();
}
inline ::remote::Robot* SCRobot::add_robot() {
  ::remote::Robot* _add = _internal_add_robot();
  // @@protoc_insertion_point(field_add:remote.SCRobot.robot)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::remote::Robot >&
SCRobot::robot() const {
  // @@protoc_insertion_point(field_list:remote.SCRobot.robot)
  return robot_;
}

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

// Leave

// int32 peer = 1;
inline void Leave::clear_peer() {
  peer_ = 0;
}
inline int32_t Leave::_internal_peer() const {
  return peer_;
}
inline int32_t Leave::peer() const {
  // @@protoc_insertion_point(field_get:remote.Leave.peer)
  return _internal_peer();
}
inline void Leave::_internal_set_peer(int32_t value) {
  
  peer_ = value;
}
inline void Leave::set_peer(int32_t value) {
  _internal_set_peer(value);
  // @@protoc_insertion_point(field_set:remote.Leave.peer)
}

// int32 egotype = 2;
inline void Leave::clear_egotype() {
  egotype_ = 0;
}
inline int32_t Leave::_internal_egotype() const {
  return egotype_;
}
inline int32_t Leave::egotype() const {
  // @@protoc_insertion_point(field_get:remote.Leave.egotype)
  return _internal_egotype();
}
inline void Leave::_internal_set_egotype(int32_t value) {
  
  egotype_ = value;
}
inline void Leave::set_egotype(int32_t value) {
  _internal_set_egotype(value);
  // @@protoc_insertion_point(field_set:remote.Leave.egotype)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace remote

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::remote::cs_message> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::remote::cs_message>() {
  return ::remote::cs_message_descriptor();
}
template <> struct is_proto_enum< ::remote::sc_message> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::remote::sc_message>() {
  return ::remote::sc_message_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_remote_2eproto