D3076.1765225844.diff
No OneTemporary
Actions

Size

739 KB

Referenced Files

None

Subscribers

None

D3076.1765225844.diff
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h
	--- a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h
	+++ b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h
	@@ -35,107 +35,113 @@
	class StubInterface {
	public:
	virtual ~StubInterface() {}
	- std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>> ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
	- return std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>>(ResetKeyRaw(context, response));
	+ std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> CreateNewBackup(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(CreateNewBackupRaw(context));
	}
	- std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>> AsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
	- return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>>(AsyncResetKeyRaw(context, response, cq, tag));
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> AsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(AsyncCreateNewBackupRaw(context, cq, tag));
	}
	- std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>> PrepareAsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>>(PrepareAsyncResetKeyRaw(context, response, cq));
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> PrepareAsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(PrepareAsyncCreateNewBackupRaw(context, cq));
	}
	- virtual ::grpc::Status SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) = 0;
	- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncSendLogRaw(context, request, cq));
	+ std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
	+ return std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>>(SendLogRaw(context, response));
	}
	- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncSendLogRaw(context, request, cq));
	+ std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>>(AsyncSendLogRaw(context, response, cq, tag));
	}
	- virtual ::grpc::Status PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) = 0;
	- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>> AsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>>(AsyncPullBackupKeyRaw(context, request, cq));
	+ std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>>(PrepareAsyncSendLogRaw(context, response, cq));
	}
	- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>> PrepareAsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>>(PrepareAsyncPullBackupKeyRaw(context, request, cq));
	+ std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> RecoverBackupKey(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(RecoverBackupKeyRaw(context));
	}
	- std::unique_ptr< ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>> PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) {
	- return std::unique_ptr< ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>>(PullCompactionRaw(context, request));
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> AsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(AsyncRecoverBackupKeyRaw(context, cq, tag));
	}
	- std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>> AsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
	- return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>>(AsyncPullCompactionRaw(context, request, cq, tag));
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> PrepareAsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(PrepareAsyncRecoverBackupKeyRaw(context, cq));
	}
	- std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>> PrepareAsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>>(PrepareAsyncPullCompactionRaw(context, request, cq));
	+ std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PullBackup(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PullBackupRaw(context));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> AsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(AsyncPullBackupRaw(context, cq, tag));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PrepareAsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PrepareAsyncPullBackupRaw(context, cq));
	}
	class async_interface {
	public:
	virtual ~async_interface() {}
	- virtual void ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) = 0;
	- virtual void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) = 0;
	- virtual void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0;
	- virtual void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function<void(::grpc::Status)>) = 0;
	- virtual void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
	- virtual void PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) = 0;
	+ virtual void CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) = 0;
	+ virtual void SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) = 0;
	+ virtual void RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) = 0;
	+ virtual void PullBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupRequest,::backup::PullBackupResponse>* reactor) = 0;
	};
	typedef class async_interface experimental_async_interface;
	virtual class async_interface* async() { return nullptr; }
	class async_interface* experimental_async() { return async(); }
	private:
	- virtual ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>* ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) = 0;
	- virtual ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>* AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) = 0;
	- virtual ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>* PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) = 0;
	- virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) = 0;
	- virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) = 0;
	- virtual ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>* AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) = 0;
	- virtual ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>* PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) = 0;
	- virtual ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>* PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) = 0;
	- virtual ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>* AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0;
	- virtual ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>* PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) = 0;
	+ virtual ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackupRaw(::grpc::ClientContext* context) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
	+ virtual ::grpc::ClientWriterInterface< ::backup::SendLogRequest>* SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) = 0;
	+ virtual ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>* AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) = 0;
	+ virtual ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) = 0;
	+ virtual ::grpc::ClientReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* RecoverBackupKeyRaw(::grpc::ClientContext* context) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* AsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* PrepareAsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
	+ virtual ::grpc::ClientReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PullBackupRaw(::grpc::ClientContext* context) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* AsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
	};
	class Stub final : public StubInterface {
	public:
	Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
	- std::unique_ptr< ::grpc::ClientWriter< ::backup::ResetKeyRequest>> ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
	- return std::unique_ptr< ::grpc::ClientWriter< ::backup::ResetKeyRequest>>(ResetKeyRaw(context, response));
	+ std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> CreateNewBackup(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(CreateNewBackupRaw(context));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> AsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(AsyncCreateNewBackupRaw(context, cq, tag));
	}
	- std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>> AsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
	- return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>>(AsyncResetKeyRaw(context, response, cq, tag));
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> PrepareAsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(PrepareAsyncCreateNewBackupRaw(context, cq));
	}
	- std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>> PrepareAsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>>(PrepareAsyncResetKeyRaw(context, response, cq));
	+ std::unique_ptr< ::grpc::ClientWriter< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
	+ return std::unique_ptr< ::grpc::ClientWriter< ::backup::SendLogRequest>>(SendLogRaw(context, response));
	}
	- ::grpc::Status SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) override;
	- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncSendLogRaw(context, request, cq));
	+ std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>>(AsyncSendLogRaw(context, response, cq, tag));
	}
	- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncSendLogRaw(context, request, cq));
	+ std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>>(PrepareAsyncSendLogRaw(context, response, cq));
	}
	- ::grpc::Status PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) override;
	- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>> AsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>>(AsyncPullBackupKeyRaw(context, request, cq));
	+ std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> RecoverBackupKey(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(RecoverBackupKeyRaw(context));
	}
	- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>> PrepareAsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>>(PrepareAsyncPullBackupKeyRaw(context, request, cq));
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> AsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(AsyncRecoverBackupKeyRaw(context, cq, tag));
	}
	- std::unique_ptr< ::grpc::ClientReader< ::backup::PullCompactionResponse>> PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) {
	- return std::unique_ptr< ::grpc::ClientReader< ::backup::PullCompactionResponse>>(PullCompactionRaw(context, request));
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> PrepareAsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(PrepareAsyncRecoverBackupKeyRaw(context, cq));
	}
	- std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>> AsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
	- return std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>>(AsyncPullCompactionRaw(context, request, cq, tag));
	+ std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PullBackup(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PullBackupRaw(context));
	}
	- std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>> PrepareAsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) {
	- return std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>>(PrepareAsyncPullCompactionRaw(context, request, cq));
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> AsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(AsyncPullBackupRaw(context, cq, tag));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PrepareAsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PrepareAsyncPullBackupRaw(context, cq));
	}
	class async final :
	public StubInterface::async_interface {
	public:
	- void ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) override;
	- void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) override;
	- void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override;
	- void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function<void(::grpc::Status)>) override;
	- void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
	- void PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) override;
	+ void CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) override;
	+ void SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) override;
	+ void RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) override;
	+ void PullBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupRequest,::backup::PullBackupResponse>* reactor) override;
	private:
	friend class Stub;
	explicit async(Stub* stub): stub_(stub) { }
	@@ -147,20 +153,22 @@
	private:
	std::shared_ptr< ::grpc::ChannelInterface> channel_;
	class async async_stub_{this};
	- ::grpc::ClientWriter< ::backup::ResetKeyRequest>* ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) override;
	- ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) override;
	- ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) override;
	- ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) override;
	- ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) override;
	- ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) override;
	- ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) override;
	- ::grpc::ClientReader< ::backup::PullCompactionResponse>* PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) override;
	- ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) override;
	- ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) override;
	- const ::grpc::internal::RpcMethod rpcmethod_ResetKey_;
	+ ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackupRaw(::grpc::ClientContext* context) override;
	+ ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
	+ ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
	+ ::grpc::ClientWriter< ::backup::SendLogRequest>* SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) override;
	+ ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) override;
	+ ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) override;
	+ ::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* RecoverBackupKeyRaw(::grpc::ClientContext* context) override;
	+ ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* AsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
	+ ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* PrepareAsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
	+ ::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PullBackupRaw(::grpc::ClientContext* context) override;
	+ ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* AsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
	+ ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
	+ const ::grpc::internal::RpcMethod rpcmethod_CreateNewBackup_;
	const ::grpc::internal::RpcMethod rpcmethod_SendLog_;
	- const ::grpc::internal::RpcMethod rpcmethod_PullBackupKey_;
	- const ::grpc::internal::RpcMethod rpcmethod_PullCompaction_;
	+ const ::grpc::internal::RpcMethod rpcmethod_RecoverBackupKey_;
	+ const ::grpc::internal::RpcMethod rpcmethod_PullBackup_;
	};
	static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

	@@ -168,29 +176,29 @@
	public:
	Service();
	virtual ~Service();
	- virtual ::grpc::Status ResetKey(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::ResetKeyRequest>* reader, ::google::protobuf::Empty* response);
	- virtual ::grpc::Status SendLog(::grpc::ServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response);
	- virtual ::grpc::Status PullBackupKey(::grpc::ServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response);
	- virtual ::grpc::Status PullCompaction(::grpc::ServerContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* writer);
	+ virtual ::grpc::Status CreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream);
	+ virtual ::grpc::Status SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::google::protobuf::Empty* response);
	+ virtual ::grpc::Status RecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* stream);
	+ virtual ::grpc::Status PullBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* stream);
	};
	template <class BaseClass>
	- class WithAsyncMethod_ResetKey : public BaseClass {
	+ class WithAsyncMethod_CreateNewBackup : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithAsyncMethod_ResetKey() {
	+ WithAsyncMethod_CreateNewBackup() {
	::grpc::Service::MarkMethodAsync(0);
	}
	- ~WithAsyncMethod_ResetKey() override {
	+ ~WithAsyncMethod_CreateNewBackup() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status ResetKey(::grpc::ServerContext* /context/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /reader/, ::google::protobuf::Empty* /response/) override {
	+ ::grpc::Status CreateNewBackup(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- void RequestResetKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::google::protobuf::Empty, ::backup::ResetKeyRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	- ::grpc::Service::RequestAsyncClientStreaming(0, context, reader, new_call_cq, notification_cq, tag);
	+ void RequestCreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag);
	}
	};
	template <class BaseClass>
	@@ -205,76 +213,77 @@
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status SendLog(::grpc::ServerContext* /context/, const ::backup::SendLogRequest* /request/, ::google::protobuf::Empty* /response/) override {
	+ ::grpc::Status SendLog(::grpc::ServerContext* /context/, ::grpc::ServerReader< ::backup::SendLogRequest>* /reader/, ::google::protobuf::Empty* /response/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- void RequestSendLog(::grpc::ServerContext* context, ::backup::SendLogRequest* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	- ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
	+ void RequestSendLog(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::google::protobuf::Empty, ::backup::SendLogRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag);
	}
	};
	template <class BaseClass>
	- class WithAsyncMethod_PullBackupKey : public BaseClass {
	+ class WithAsyncMethod_RecoverBackupKey : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithAsyncMethod_PullBackupKey() {
	+ WithAsyncMethod_RecoverBackupKey() {
	::grpc::Service::MarkMethodAsync(2);
	}
	- ~WithAsyncMethod_PullBackupKey() override {
	+ ~WithAsyncMethod_RecoverBackupKey() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status PullBackupKey(::grpc::ServerContext* /context/, const ::backup::PullBackupKeyRequest* /request/, ::backup::PullBackupKeyResponse* /response/) override {
	+ ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- void RequestPullBackupKey(::grpc::ServerContext* context, ::backup::PullBackupKeyRequest* request, ::grpc::ServerAsyncResponseWriter< ::backup::PullBackupKeyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	- ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
	+ void RequestRecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncBidiStreaming(2, context, stream, new_call_cq, notification_cq, tag);
	}
	};
	template <class BaseClass>
	- class WithAsyncMethod_PullCompaction : public BaseClass {
	+ class WithAsyncMethod_PullBackup : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithAsyncMethod_PullCompaction() {
	+ WithAsyncMethod_PullBackup() {
	::grpc::Service::MarkMethodAsync(3);
	}
	- ~WithAsyncMethod_PullCompaction() override {
	+ ~WithAsyncMethod_PullBackup() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status PullCompaction(::grpc::ServerContext* /context/, const ::backup::PullCompactionRequest* /request/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /writer/) override {
	+ ::grpc::Status PullBackup(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- void RequestPullCompaction(::grpc::ServerContext* context, ::backup::PullCompactionRequest* request, ::grpc::ServerAsyncWriter< ::backup::PullCompactionResponse>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	- ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag);
	+ void RequestPullBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag);
	}
	};
	- typedef WithAsyncMethod_ResetKey<WithAsyncMethod_SendLog<WithAsyncMethod_PullBackupKey<WithAsyncMethod_PullCompaction<Service > > > > AsyncService;
	+ typedef WithAsyncMethod_CreateNewBackup<WithAsyncMethod_SendLog<WithAsyncMethod_RecoverBackupKey<WithAsyncMethod_PullBackup<Service > > > > AsyncService;
	template <class BaseClass>
	- class WithCallbackMethod_ResetKey : public BaseClass {
	+ class WithCallbackMethod_CreateNewBackup : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithCallbackMethod_ResetKey() {
	+ WithCallbackMethod_CreateNewBackup() {
	::grpc::Service::MarkMethodCallback(0,
	- new ::grpc::internal::CallbackClientStreamingHandler< ::backup::ResetKeyRequest, ::google::protobuf::Empty>(
	+ new ::grpc::internal::CallbackBidiHandler< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>(
	[this](
	- ::grpc::CallbackServerContext* context, ::google::protobuf::Empty* response) { return this->ResetKey(context, response); }));
	+ ::grpc::CallbackServerContext* context) { return this->CreateNewBackup(context); }));
	}
	- ~WithCallbackMethod_ResetKey() override {
	+ ~WithCallbackMethod_CreateNewBackup() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status ResetKey(::grpc::ServerContext* /context/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /reader/, ::google::protobuf::Empty* /response/) override {
	+ ::grpc::Status CreateNewBackup(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- virtual ::grpc::ServerReadReactor< ::backup::ResetKeyRequest>* ResetKey(
	- ::grpc::CallbackServerContext* /context/, ::google::protobuf::Empty* /response/) { return nullptr; }
	+ virtual ::grpc::ServerBidiReactor< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackup(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	};
	template <class BaseClass>
	class WithCallbackMethod_SendLog : public BaseClass {
	@@ -283,90 +292,82 @@
	public:
	WithCallbackMethod_SendLog() {
	::grpc::Service::MarkMethodCallback(1,
	- new ::grpc::internal::CallbackUnaryHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>(
	+ new ::grpc::internal::CallbackClientStreamingHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>(
	[this](
	- ::grpc::CallbackServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response) { return this->SendLog(context, request, response); }));}
	- void SetMessageAllocatorFor_SendLog(
	- ::grpc::MessageAllocator< ::backup::SendLogRequest, ::google::protobuf::Empty>* allocator) {
	- ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
	- static_cast<::grpc::internal::CallbackUnaryHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>*>(handler)
	- ->SetMessageAllocator(allocator);
	+ ::grpc::CallbackServerContext* context, ::google::protobuf::Empty* response) { return this->SendLog(context, response); }));
	}
	~WithCallbackMethod_SendLog() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status SendLog(::grpc::ServerContext* /context/, const ::backup::SendLogRequest* /request/, ::google::protobuf::Empty* /response/) override {
	+ ::grpc::Status SendLog(::grpc::ServerContext* /context/, ::grpc::ServerReader< ::backup::SendLogRequest>* /reader/, ::google::protobuf::Empty* /response/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- virtual ::grpc::ServerUnaryReactor* SendLog(
	- ::grpc::CallbackServerContext* /context/, const ::backup::SendLogRequest* /request/, ::google::protobuf::Empty* /response/) { return nullptr; }
	+ virtual ::grpc::ServerReadReactor< ::backup::SendLogRequest>* SendLog(
	+ ::grpc::CallbackServerContext* /context/, ::google::protobuf::Empty* /response/) { return nullptr; }
	};
	template <class BaseClass>
	- class WithCallbackMethod_PullBackupKey : public BaseClass {
	+ class WithCallbackMethod_RecoverBackupKey : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithCallbackMethod_PullBackupKey() {
	+ WithCallbackMethod_RecoverBackupKey() {
	::grpc::Service::MarkMethodCallback(2,
	- new ::grpc::internal::CallbackUnaryHandler< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>(
	+ new ::grpc::internal::CallbackBidiHandler< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>(
	[this](
	- ::grpc::CallbackServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response) { return this->PullBackupKey(context, request, response); }));}
	- void SetMessageAllocatorFor_PullBackupKey(
	- ::grpc::MessageAllocator< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* allocator) {
	- ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
	- static_cast<::grpc::internal::CallbackUnaryHandler< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>*>(handler)
	- ->SetMessageAllocator(allocator);
	- }
	- ~WithCallbackMethod_PullBackupKey() override {
	+ ::grpc::CallbackServerContext* context) { return this->RecoverBackupKey(context); }));
	+ }
	+ ~WithCallbackMethod_RecoverBackupKey() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status PullBackupKey(::grpc::ServerContext* /context/, const ::backup::PullBackupKeyRequest* /request/, ::backup::PullBackupKeyResponse* /response/) override {
	+ ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- virtual ::grpc::ServerUnaryReactor* PullBackupKey(
	- ::grpc::CallbackServerContext* /context/, const ::backup::PullBackupKeyRequest* /request/, ::backup::PullBackupKeyResponse* /response/) { return nullptr; }
	+ virtual ::grpc::ServerBidiReactor< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* RecoverBackupKey(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	};
	template <class BaseClass>
	- class WithCallbackMethod_PullCompaction : public BaseClass {
	+ class WithCallbackMethod_PullBackup : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithCallbackMethod_PullCompaction() {
	+ WithCallbackMethod_PullBackup() {
	::grpc::Service::MarkMethodCallback(3,
	- new ::grpc::internal::CallbackServerStreamingHandler< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>(
	+ new ::grpc::internal::CallbackBidiHandler< ::backup::PullBackupRequest, ::backup::PullBackupResponse>(
	[this](
	- ::grpc::CallbackServerContext* context, const ::backup::PullCompactionRequest* request) { return this->PullCompaction(context, request); }));
	+ ::grpc::CallbackServerContext* context) { return this->PullBackup(context); }));
	}
	- ~WithCallbackMethod_PullCompaction() override {
	+ ~WithCallbackMethod_PullBackup() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status PullCompaction(::grpc::ServerContext* /context/, const ::backup::PullCompactionRequest* /request/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /writer/) override {
	+ ::grpc::Status PullBackup(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- virtual ::grpc::ServerWriteReactor< ::backup::PullCompactionResponse>* PullCompaction(
	- ::grpc::CallbackServerContext* /context/, const ::backup::PullCompactionRequest* /request/) { return nullptr; }
	+ virtual ::grpc::ServerBidiReactor< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PullBackup(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	};
	- typedef WithCallbackMethod_ResetKey<WithCallbackMethod_SendLog<WithCallbackMethod_PullBackupKey<WithCallbackMethod_PullCompaction<Service > > > > CallbackService;
	+ typedef WithCallbackMethod_CreateNewBackup<WithCallbackMethod_SendLog<WithCallbackMethod_RecoverBackupKey<WithCallbackMethod_PullBackup<Service > > > > CallbackService;
	typedef CallbackService ExperimentalCallbackService;
	template <class BaseClass>
	- class WithGenericMethod_ResetKey : public BaseClass {
	+ class WithGenericMethod_CreateNewBackup : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithGenericMethod_ResetKey() {
	+ WithGenericMethod_CreateNewBackup() {
	::grpc::Service::MarkMethodGeneric(0);
	}
	- ~WithGenericMethod_ResetKey() override {
	+ ~WithGenericMethod_CreateNewBackup() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status ResetKey(::grpc::ServerContext* /context/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /reader/, ::google::protobuf::Empty* /response/) override {
	+ ::grpc::Status CreateNewBackup(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	@@ -383,63 +384,63 @@
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status SendLog(::grpc::ServerContext* /context/, const ::backup::SendLogRequest* /request/, ::google::protobuf::Empty* /response/) override {
	+ ::grpc::Status SendLog(::grpc::ServerContext* /context/, ::grpc::ServerReader< ::backup::SendLogRequest>* /reader/, ::google::protobuf::Empty* /response/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	};
	template <class BaseClass>
	- class WithGenericMethod_PullBackupKey : public BaseClass {
	+ class WithGenericMethod_RecoverBackupKey : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithGenericMethod_PullBackupKey() {
	+ WithGenericMethod_RecoverBackupKey() {
	::grpc::Service::MarkMethodGeneric(2);
	}
	- ~WithGenericMethod_PullBackupKey() override {
	+ ~WithGenericMethod_RecoverBackupKey() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status PullBackupKey(::grpc::ServerContext* /context/, const ::backup::PullBackupKeyRequest* /request/, ::backup::PullBackupKeyResponse* /response/) override {
	+ ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	};
	template <class BaseClass>
	- class WithGenericMethod_PullCompaction : public BaseClass {
	+ class WithGenericMethod_PullBackup : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithGenericMethod_PullCompaction() {
	+ WithGenericMethod_PullBackup() {
	::grpc::Service::MarkMethodGeneric(3);
	}
	- ~WithGenericMethod_PullCompaction() override {
	+ ~WithGenericMethod_PullBackup() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status PullCompaction(::grpc::ServerContext* /context/, const ::backup::PullCompactionRequest* /request/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /writer/) override {
	+ ::grpc::Status PullBackup(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	};
	template <class BaseClass>
	- class WithRawMethod_ResetKey : public BaseClass {
	+ class WithRawMethod_CreateNewBackup : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithRawMethod_ResetKey() {
	+ WithRawMethod_CreateNewBackup() {
	::grpc::Service::MarkMethodRaw(0);
	}
	- ~WithRawMethod_ResetKey() override {
	+ ~WithRawMethod_CreateNewBackup() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status ResetKey(::grpc::ServerContext* /context/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /reader/, ::google::protobuf::Empty* /response/) override {
	+ ::grpc::Status CreateNewBackup(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- void RequestResetKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	- ::grpc::Service::RequestAsyncClientStreaming(0, context, reader, new_call_cq, notification_cq, tag);
	+ void RequestCreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag);
	}
	};
	template <class BaseClass>
	@@ -454,75 +455,76 @@
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status SendLog(::grpc::ServerContext* /context/, const ::backup::SendLogRequest* /request/, ::google::protobuf::Empty* /response/) override {
	+ ::grpc::Status SendLog(::grpc::ServerContext* /context/, ::grpc::ServerReader< ::backup::SendLogRequest>* /reader/, ::google::protobuf::Empty* /response/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- void RequestSendLog(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	- ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
	+ void RequestSendLog(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag);
	}
	};
	template <class BaseClass>
	- class WithRawMethod_PullBackupKey : public BaseClass {
	+ class WithRawMethod_RecoverBackupKey : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithRawMethod_PullBackupKey() {
	+ WithRawMethod_RecoverBackupKey() {
	::grpc::Service::MarkMethodRaw(2);
	}
	- ~WithRawMethod_PullBackupKey() override {
	+ ~WithRawMethod_RecoverBackupKey() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status PullBackupKey(::grpc::ServerContext* /context/, const ::backup::PullBackupKeyRequest* /request/, ::backup::PullBackupKeyResponse* /response/) override {
	+ ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- void RequestPullBackupKey(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	- ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
	+ void RequestRecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncBidiStreaming(2, context, stream, new_call_cq, notification_cq, tag);
	}
	};
	template <class BaseClass>
	- class WithRawMethod_PullCompaction : public BaseClass {
	+ class WithRawMethod_PullBackup : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithRawMethod_PullCompaction() {
	+ WithRawMethod_PullBackup() {
	::grpc::Service::MarkMethodRaw(3);
	}
	- ~WithRawMethod_PullCompaction() override {
	+ ~WithRawMethod_PullBackup() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status PullCompaction(::grpc::ServerContext* /context/, const ::backup::PullCompactionRequest* /request/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /writer/) override {
	+ ::grpc::Status PullBackup(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- void RequestPullCompaction(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	- ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag);
	+ void RequestPullBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag);
	}
	};
	template <class BaseClass>
	- class WithRawCallbackMethod_ResetKey : public BaseClass {
	+ class WithRawCallbackMethod_CreateNewBackup : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithRawCallbackMethod_ResetKey() {
	+ WithRawCallbackMethod_CreateNewBackup() {
	::grpc::Service::MarkMethodRawCallback(0,
	- new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	+ new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	[this](
	- ::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->ResetKey(context, response); }));
	+ ::grpc::CallbackServerContext* context) { return this->CreateNewBackup(context); }));
	}
	- ~WithRawCallbackMethod_ResetKey() override {
	+ ~WithRawCallbackMethod_CreateNewBackup() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status ResetKey(::grpc::ServerContext* /context/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /reader/, ::google::protobuf::Empty* /response/) override {
	+ ::grpc::Status CreateNewBackup(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* ResetKey(
	- ::grpc::CallbackServerContext* /context/, ::grpc::ByteBuffer* /response/) { return nullptr; }
	+ virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* CreateNewBackup(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	};
	template <class BaseClass>
	class WithRawCallbackMethod_SendLog : public BaseClass {
	@@ -531,149 +533,70 @@
	public:
	WithRawCallbackMethod_SendLog() {
	::grpc::Service::MarkMethodRawCallback(1,
	- new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	+ new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	[this](
	- ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendLog(context, request, response); }));
	+ ::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->SendLog(context, response); }));
	}
	~WithRawCallbackMethod_SendLog() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status SendLog(::grpc::ServerContext* /context/, const ::backup::SendLogRequest* /request/, ::google::protobuf::Empty* /response/) override {
	+ ::grpc::Status SendLog(::grpc::ServerContext* /context/, ::grpc::ServerReader< ::backup::SendLogRequest>* /reader/, ::google::protobuf::Empty* /response/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- virtual ::grpc::ServerUnaryReactor* SendLog(
	- ::grpc::CallbackServerContext* /context/, const ::grpc::ByteBuffer* /request/, ::grpc::ByteBuffer* /response/) { return nullptr; }
	+ virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* SendLog(
	+ ::grpc::CallbackServerContext* /context/, ::grpc::ByteBuffer* /response/) { return nullptr; }
	};
	template <class BaseClass>
	- class WithRawCallbackMethod_PullBackupKey : public BaseClass {
	+ class WithRawCallbackMethod_RecoverBackupKey : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithRawCallbackMethod_PullBackupKey() {
	+ WithRawCallbackMethod_RecoverBackupKey() {
	::grpc::Service::MarkMethodRawCallback(2,
	- new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	+ new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	[this](
	- ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PullBackupKey(context, request, response); }));
	+ ::grpc::CallbackServerContext* context) { return this->RecoverBackupKey(context); }));
	}
	- ~WithRawCallbackMethod_PullBackupKey() override {
	+ ~WithRawCallbackMethod_RecoverBackupKey() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status PullBackupKey(::grpc::ServerContext* /context/, const ::backup::PullBackupKeyRequest* /request/, ::backup::PullBackupKeyResponse* /response/) override {
	+ ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- virtual ::grpc::ServerUnaryReactor* PullBackupKey(
	- ::grpc::CallbackServerContext* /context/, const ::grpc::ByteBuffer* /request/, ::grpc::ByteBuffer* /response/) { return nullptr; }
	+ virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* RecoverBackupKey(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	};
	template <class BaseClass>
	- class WithRawCallbackMethod_PullCompaction : public BaseClass {
	+ class WithRawCallbackMethod_PullBackup : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	public:
	- WithRawCallbackMethod_PullCompaction() {
	+ WithRawCallbackMethod_PullBackup() {
	::grpc::Service::MarkMethodRawCallback(3,
	- new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	+ new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	[this](
	- ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->PullCompaction(context, request); }));
	+ ::grpc::CallbackServerContext* context) { return this->PullBackup(context); }));
	}
	- ~WithRawCallbackMethod_PullCompaction() override {
	+ ~WithRawCallbackMethod_PullBackup() override {
	BaseClassMustBeDerivedFromService(this);
	}
	// disable synchronous version of this method
	- ::grpc::Status PullCompaction(::grpc::ServerContext* /context/, const ::backup::PullCompactionRequest* /request/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /writer/) override {
	- abort();
	- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	- }
	- virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* PullCompaction(
	- ::grpc::CallbackServerContext* /context/, const ::grpc::ByteBuffer* /request/) { return nullptr; }
	- };
	- template <class BaseClass>
	- class WithStreamedUnaryMethod_SendLog : public BaseClass {
	- private:
	- void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	- public:
	- WithStreamedUnaryMethod_SendLog() {
	- ::grpc::Service::MarkMethodStreamed(1,
	- new ::grpc::internal::StreamedUnaryHandler<
	- ::backup::SendLogRequest, ::google::protobuf::Empty>(
	- [this](::grpc::ServerContext* context,
	- ::grpc::ServerUnaryStreamer<
	- ::backup::SendLogRequest, ::google::protobuf::Empty>* streamer) {
	- return this->StreamedSendLog(context,
	- streamer);
	- }));
	- }
	- ~WithStreamedUnaryMethod_SendLog() override {
	- BaseClassMustBeDerivedFromService(this);
	- }
	- // disable regular version of this method
	- ::grpc::Status SendLog(::grpc::ServerContext* /context/, const ::backup::SendLogRequest* /request/, ::google::protobuf::Empty* /response/) override {
	- abort();
	- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	- }
	- // replace default version of method with streamed unary
	- virtual ::grpc::Status StreamedSendLog(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::backup::SendLogRequest,::google::protobuf::Empty>* server_unary_streamer) = 0;
	- };
	- template <class BaseClass>
	- class WithStreamedUnaryMethod_PullBackupKey : public BaseClass {
	- private:
	- void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	- public:
	- WithStreamedUnaryMethod_PullBackupKey() {
	- ::grpc::Service::MarkMethodStreamed(2,
	- new ::grpc::internal::StreamedUnaryHandler<
	- ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>(
	- [this](::grpc::ServerContext* context,
	- ::grpc::ServerUnaryStreamer<
	- ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* streamer) {
	- return this->StreamedPullBackupKey(context,
	- streamer);
	- }));
	- }
	- ~WithStreamedUnaryMethod_PullBackupKey() override {
	- BaseClassMustBeDerivedFromService(this);
	- }
	- // disable regular version of this method
	- ::grpc::Status PullBackupKey(::grpc::ServerContext* /context/, const ::backup::PullBackupKeyRequest* /request/, ::backup::PullBackupKeyResponse* /response/) override {
	- abort();
	- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	- }
	- // replace default version of method with streamed unary
	- virtual ::grpc::Status StreamedPullBackupKey(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::backup::PullBackupKeyRequest,::backup::PullBackupKeyResponse>* server_unary_streamer) = 0;
	- };
	- typedef WithStreamedUnaryMethod_SendLog<WithStreamedUnaryMethod_PullBackupKey<Service > > StreamedUnaryService;
	- template <class BaseClass>
	- class WithSplitStreamingMethod_PullCompaction : public BaseClass {
	- private:
	- void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	- public:
	- WithSplitStreamingMethod_PullCompaction() {
	- ::grpc::Service::MarkMethodStreamed(3,
	- new ::grpc::internal::SplitServerStreamingHandler<
	- ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>(
	- [this](::grpc::ServerContext* context,
	- ::grpc::ServerSplitStreamer<
	- ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* streamer) {
	- return this->StreamedPullCompaction(context,
	- streamer);
	- }));
	- }
	- ~WithSplitStreamingMethod_PullCompaction() override {
	- BaseClassMustBeDerivedFromService(this);
	- }
	- // disable regular version of this method
	- ::grpc::Status PullCompaction(::grpc::ServerContext* /context/, const ::backup::PullCompactionRequest* /request/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /writer/) override {
	+ ::grpc::Status PullBackup(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /stream/) override {
	abort();
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}
	- // replace default version of method with split streamed
	- virtual ::grpc::Status StreamedPullCompaction(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::backup::PullCompactionRequest,::backup::PullCompactionResponse>* server_split_streamer) = 0;
	+ virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* PullBackup(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	};
	- typedef WithSplitStreamingMethod_PullCompaction<Service > SplitStreamedService;
	- typedef WithStreamedUnaryMethod_SendLog<WithStreamedUnaryMethod_PullBackupKey<WithSplitStreamingMethod_PullCompaction<Service > > > StreamedService;
	+ typedef Service StreamedUnaryService;
	+ typedef Service SplitStreamedService;
	+ typedef Service StreamedService;
	};

	} // namespace backup
	diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
	--- a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
	+++ b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
	@@ -22,10 +22,10 @@
	namespace backup {

	static const char* BackupService_method_names[] = {
	- "/backup.BackupService/ResetKey",
	+ "/backup.BackupService/CreateNewBackup",
	"/backup.BackupService/SendLog",
	- "/backup.BackupService/PullBackupKey",
	- "/backup.BackupService/PullCompaction",
	+ "/backup.BackupService/RecoverBackupKey",
	+ "/backup.BackupService/PullBackup",
	};

	std::unique_ptr< BackupService::Stub> BackupService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
	@@ -35,161 +35,144 @@
	}

	BackupService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
	- : channel_(channel), rpcmethod_ResetKey_(BackupService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel)
	- , rpcmethod_SendLog_(BackupService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
	- , rpcmethod_PullBackupKey_(BackupService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
	- , rpcmethod_PullCompaction_(BackupService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
	+ : channel_(channel), rpcmethod_CreateNewBackup_(BackupService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
	+ , rpcmethod_SendLog_(BackupService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel)
	+ , rpcmethod_RecoverBackupKey_(BackupService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
	+ , rpcmethod_PullBackup_(BackupService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
	{}

	-::grpc::ClientWriter< ::backup::ResetKeyRequest>* BackupService::Stub::ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
	- return ::grpc::internal::ClientWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), rpcmethod_ResetKey_, context, response);
	+::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::CreateNewBackupRaw(::grpc::ClientContext* context) {
	+ return ::grpc::internal::ClientReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), rpcmethod_CreateNewBackup_, context);
	}

	-void BackupService::Stub::async::ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) {
	- ::grpc::internal::ClientCallbackWriterFactory< ::backup::ResetKeyRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_ResetKey_, context, response, reactor);
	+void BackupService::Stub::async::CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) {
	+ ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_CreateNewBackup_, context, reactor);
	}

	-::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* BackupService::Stub::AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
	- return ::grpc::internal::ClientAsyncWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), cq, rpcmethod_ResetKey_, context, response, true, tag);
	+::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), cq, rpcmethod_CreateNewBackup_, context, true, tag);
	}

	-::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* BackupService::Stub::PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
	- return ::grpc::internal::ClientAsyncWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), cq, rpcmethod_ResetKey_, context, response, false, nullptr);
	+::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), cq, rpcmethod_CreateNewBackup_, context, false, nullptr);
	}

	-::grpc::Status BackupService::Stub::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) {
	- return ::grpc::internal::BlockingUnaryCall< ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SendLog_, context, request, response);
	+::grpc::ClientWriter< ::backup::SendLogRequest>* BackupService::Stub::SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
	+ return ::grpc::internal::ClientWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), rpcmethod_SendLog_, context, response);
	}

	-void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
	- ::grpc::internal::CallbackUnaryCall< ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, request, response, std::move(f));
	+void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) {
	+ ::grpc::internal::ClientCallbackWriterFactory< ::backup::SendLogRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, response, reactor);
	}

	-void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
	- ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, request, response, reactor);
	+::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
	+ return ::grpc::internal::ClientAsyncWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), cq, rpcmethod_SendLog_, context, response, true, tag);
	}

	-::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* BackupService::Stub::PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
	- return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::backup::SendLogRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SendLog_, context, request);
	+::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
	+ return ::grpc::internal::ClientAsyncWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), cq, rpcmethod_SendLog_, context, response, false, nullptr);
	}

	-::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* BackupService::Stub::AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
	- auto* result =
	- this->PrepareAsyncSendLogRaw(context, request, cq);
	- result->StartCall();
	- return result;
	+::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* BackupService::Stub::RecoverBackupKeyRaw(::grpc::ClientContext* context) {
	+ return ::grpc::internal::ClientReaderWriterFactory< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>::Create(channel_.get(), rpcmethod_RecoverBackupKey_, context);
	}

	-::grpc::Status BackupService::Stub::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) {
	- return ::grpc::internal::BlockingUnaryCall< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PullBackupKey_, context, request, response);
	+void BackupService::Stub::async::RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) {
	+ ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_RecoverBackupKey_, context, reactor);
	}

	-void BackupService::Stub::async::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function<void(::grpc::Status)> f) {
	- ::grpc::internal::CallbackUnaryCall< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PullBackupKey_, context, request, response, std::move(f));
	+::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* BackupService::Stub::AsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>::Create(channel_.get(), cq, rpcmethod_RecoverBackupKey_, context, true, tag);
	}

	-void BackupService::Stub::async::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) {
	- ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PullBackupKey_, context, request, response, reactor);
	+::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* BackupService::Stub::PrepareAsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>::Create(channel_.get(), cq, rpcmethod_RecoverBackupKey_, context, false, nullptr);
	}

	-::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* BackupService::Stub::PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
	- return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PullBackupKey_, context, request);
	+::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* BackupService::Stub::PullBackupRaw(::grpc::ClientContext* context) {
	+ return ::grpc::internal::ClientReaderWriterFactory< ::backup::PullBackupRequest, ::backup::PullBackupResponse>::Create(channel_.get(), rpcmethod_PullBackup_, context);
	}

	-::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* BackupService::Stub::AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
	- auto* result =
	- this->PrepareAsyncPullBackupKeyRaw(context, request, cq);
	- result->StartCall();
	- return result;
	+void BackupService::Stub::async::PullBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupRequest,::backup::PullBackupResponse>* reactor) {
	+ ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::PullBackupRequest,::backup::PullBackupResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_PullBackup_, context, reactor);
	}

	-::grpc::ClientReader< ::backup::PullCompactionResponse>* BackupService::Stub::PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) {
	- return ::grpc::internal::ClientReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), rpcmethod_PullCompaction_, context, request);
	+::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* BackupService::Stub::AsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::PullBackupRequest, ::backup::PullBackupResponse>::Create(channel_.get(), cq, rpcmethod_PullBackup_, context, true, tag);
	}

	-void BackupService::Stub::async::PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) {
	- ::grpc::internal::ClientCallbackReaderFactory< ::backup::PullCompactionResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_PullCompaction_, context, request, reactor);
	-}
	-
	-::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* BackupService::Stub::AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
	- return ::grpc::internal::ClientAsyncReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), cq, rpcmethod_PullCompaction_, context, request, true, tag);
	-}
	-
	-::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* BackupService::Stub::PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) {
	- return ::grpc::internal::ClientAsyncReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), cq, rpcmethod_PullCompaction_, context, request, false, nullptr);
	+::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* BackupService::Stub::PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::PullBackupRequest, ::backup::PullBackupResponse>::Create(channel_.get(), cq, rpcmethod_PullBackup_, context, false, nullptr);
	}

	BackupService::Service::Service() {
	AddMethod(new ::grpc::internal::RpcServiceMethod(
	BackupService_method_names[0],
	- ::grpc::internal::RpcMethod::CLIENT_STREAMING,
	- new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::ResetKeyRequest, ::google::protobuf::Empty>(
	+ ::grpc::internal::RpcMethod::BIDI_STREAMING,
	+ new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>(
	[](BackupService::Service* service,
	::grpc::ServerContext* ctx,
	- ::grpc::ServerReader<::backup::ResetKeyRequest>* reader,
	- ::google::protobuf::Empty* resp) {
	- return service->ResetKey(ctx, reader, resp);
	+ ::grpc::ServerReaderWriter<::backup::CreateNewBackupResponse,
	+ ::backup::CreateNewBackupRequest>* stream) {
	+ return service->CreateNewBackup(ctx, stream);
	}, this)));
	AddMethod(new ::grpc::internal::RpcServiceMethod(
	BackupService_method_names[1],
	- ::grpc::internal::RpcMethod::NORMAL_RPC,
	- new ::grpc::internal::RpcMethodHandler< BackupService::Service, ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
	+ ::grpc::internal::RpcMethod::CLIENT_STREAMING,
	+ new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::SendLogRequest, ::google::protobuf::Empty>(
	[](BackupService::Service* service,
	::grpc::ServerContext* ctx,
	- const ::backup::SendLogRequest* req,
	+ ::grpc::ServerReader<::backup::SendLogRequest>* reader,
	::google::protobuf::Empty* resp) {
	- return service->SendLog(ctx, req, resp);
	+ return service->SendLog(ctx, reader, resp);
	}, this)));
	AddMethod(new ::grpc::internal::RpcServiceMethod(
	BackupService_method_names[2],
	- ::grpc::internal::RpcMethod::NORMAL_RPC,
	- new ::grpc::internal::RpcMethodHandler< BackupService::Service, ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
	+ ::grpc::internal::RpcMethod::BIDI_STREAMING,
	+ new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>(
	[](BackupService::Service* service,
	::grpc::ServerContext* ctx,
	- const ::backup::PullBackupKeyRequest* req,
	- ::backup::PullBackupKeyResponse* resp) {
	- return service->PullBackupKey(ctx, req, resp);
	+ ::grpc::ServerReaderWriter<::backup::RecoverBackupKeyResponse,
	+ ::backup::RecoverBackupKeyRequest>* stream) {
	+ return service->RecoverBackupKey(ctx, stream);
	}, this)));
	AddMethod(new ::grpc::internal::RpcServiceMethod(
	BackupService_method_names[3],
	- ::grpc::internal::RpcMethod::SERVER_STREAMING,
	- new ::grpc::internal::ServerStreamingHandler< BackupService::Service, ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>(
	+ ::grpc::internal::RpcMethod::BIDI_STREAMING,
	+ new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::PullBackupRequest, ::backup::PullBackupResponse>(
	[](BackupService::Service* service,
	::grpc::ServerContext* ctx,
	- const ::backup::PullCompactionRequest* req,
	- ::grpc::ServerWriter<::backup::PullCompactionResponse>* writer) {
	- return service->PullCompaction(ctx, req, writer);
	+ ::grpc::ServerReaderWriter<::backup::PullBackupResponse,
	+ ::backup::PullBackupRequest>* stream) {
	+ return service->PullBackup(ctx, stream);
	}, this)));
	}

	BackupService::Service::~Service() {
	}

	-::grpc::Status BackupService::Service::ResetKey(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::ResetKeyRequest>* reader, ::google::protobuf::Empty* response) {
	+::grpc::Status BackupService::Service::CreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream) {
	(void) context;
	- (void) reader;
	- (void) response;
	+ (void) stream;
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}

	-::grpc::Status BackupService::Service::SendLog(::grpc::ServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response) {
	+::grpc::Status BackupService::Service::SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::google::protobuf::Empty* response) {
	(void) context;
	- (void) request;
	+ (void) reader;
	(void) response;
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}

	-::grpc::Status BackupService::Service::PullBackupKey(::grpc::ServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response) {
	+::grpc::Status BackupService::Service::RecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* stream) {
	(void) context;
	- (void) request;
	- (void) response;
	+ (void) stream;
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}

	-::grpc::Status BackupService::Service::PullCompaction(::grpc::ServerContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* writer) {
	+::grpc::Status BackupService::Service::PullBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* stream) {
	(void) context;
	- (void) request;
	- (void) writer;
	+ (void) stream;
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}

	diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.h b/native/cpp/CommonCpp/grpc/_generated/backup.pb.h
	--- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.h
	+++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.h
	@@ -47,7 +47,7 @@
	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[6]
	+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[11]
	PROTOBUF_SECTION_VARIABLE(protodesc_cold);
	static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
	static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
	@@ -56,55 +56,75 @@
	extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_backup_2eproto;
	::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_backup_2eproto_metadata_getter(int index);
	namespace backup {
	-class PullBackupKeyRequest;
	-struct PullBackupKeyRequestDefaultTypeInternal;
	-extern PullBackupKeyRequestDefaultTypeInternal _PullBackupKeyRequest_default_instance_;
	-class PullBackupKeyResponse;
	-struct PullBackupKeyResponseDefaultTypeInternal;
	-extern PullBackupKeyResponseDefaultTypeInternal _PullBackupKeyResponse_default_instance_;
	-class PullCompactionRequest;
	-struct PullCompactionRequestDefaultTypeInternal;
	-extern PullCompactionRequestDefaultTypeInternal _PullCompactionRequest_default_instance_;
	-class PullCompactionResponse;
	-struct PullCompactionResponseDefaultTypeInternal;
	-extern PullCompactionResponseDefaultTypeInternal _PullCompactionResponse_default_instance_;
	-class ResetKeyRequest;
	-struct ResetKeyRequestDefaultTypeInternal;
	-extern ResetKeyRequestDefaultTypeInternal _ResetKeyRequest_default_instance_;
	+class AuthenticationInformationData;
	+struct AuthenticationInformationDataDefaultTypeInternal;
	+extern AuthenticationInformationDataDefaultTypeInternal _AuthenticationInformationData_default_instance_;
	+class CreateNewBackupRequest;
	+struct CreateNewBackupRequestDefaultTypeInternal;
	+extern CreateNewBackupRequestDefaultTypeInternal _CreateNewBackupRequest_default_instance_;
	+class CreateNewBackupResponse;
	+struct CreateNewBackupResponseDefaultTypeInternal;
	+extern CreateNewBackupResponseDefaultTypeInternal _CreateNewBackupResponse_default_instance_;
	+class FullAuthenticationRequestData;
	+struct FullAuthenticationRequestDataDefaultTypeInternal;
	+extern FullAuthenticationRequestDataDefaultTypeInternal _FullAuthenticationRequestData_default_instance_;
	+class FullAuthenticationResponseData;
	+struct FullAuthenticationResponseDataDefaultTypeInternal;
	+extern FullAuthenticationResponseDataDefaultTypeInternal _FullAuthenticationResponseData_default_instance_;
	+class PullBackupRequest;
	+struct PullBackupRequestDefaultTypeInternal;
	+extern PullBackupRequestDefaultTypeInternal _PullBackupRequest_default_instance_;
	+class PullBackupResponse;
	+struct PullBackupResponseDefaultTypeInternal;
	+extern PullBackupResponseDefaultTypeInternal _PullBackupResponse_default_instance_;
	+class RecoverBackupKeyRequest;
	+struct RecoverBackupKeyRequestDefaultTypeInternal;
	+extern RecoverBackupKeyRequestDefaultTypeInternal _RecoverBackupKeyRequest_default_instance_;
	+class RecoverBackupKeyResponse;
	+struct RecoverBackupKeyResponseDefaultTypeInternal;
	+extern RecoverBackupKeyResponseDefaultTypeInternal _RecoverBackupKeyResponse_default_instance_;
	class SendLogRequest;
	struct SendLogRequestDefaultTypeInternal;
	extern SendLogRequestDefaultTypeInternal _SendLogRequest_default_instance_;
	+class SimpleAuthenticationRequestData;
	+struct SimpleAuthenticationRequestDataDefaultTypeInternal;
	+extern SimpleAuthenticationRequestDataDefaultTypeInternal _SimpleAuthenticationRequestData_default_instance_;
	} // namespace backup
	PROTOBUF_NAMESPACE_OPEN
	-template<> ::backup::PullBackupKeyRequest* Arena::CreateMaybeMessage<::backup::PullBackupKeyRequest>(Arena*);
	-template<> ::backup::PullBackupKeyResponse* Arena::CreateMaybeMessage<::backup::PullBackupKeyResponse>(Arena*);
	-template<> ::backup::PullCompactionRequest* Arena::CreateMaybeMessage<::backup::PullCompactionRequest>(Arena*);
	-template<> ::backup::PullCompactionResponse* Arena::CreateMaybeMessage<::backup::PullCompactionResponse>(Arena*);
	-template<> ::backup::ResetKeyRequest* Arena::CreateMaybeMessage<::backup::ResetKeyRequest>(Arena*);
	+template<> ::backup::AuthenticationInformationData* Arena::CreateMaybeMessage<::backup::AuthenticationInformationData>(Arena*);
	+template<> ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage<::backup::CreateNewBackupRequest>(Arena*);
	+template<> ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage<::backup::CreateNewBackupResponse>(Arena*);
	+template<> ::backup::FullAuthenticationRequestData* Arena::CreateMaybeMessage<::backup::FullAuthenticationRequestData>(Arena*);
	+template<> ::backup::FullAuthenticationResponseData* Arena::CreateMaybeMessage<::backup::FullAuthenticationResponseData>(Arena*);
	+template<> ::backup::PullBackupRequest* Arena::CreateMaybeMessage<::backup::PullBackupRequest>(Arena*);
	+template<> ::backup::PullBackupResponse* Arena::CreateMaybeMessage<::backup::PullBackupResponse>(Arena*);
	+template<> ::backup::RecoverBackupKeyRequest* Arena::CreateMaybeMessage<::backup::RecoverBackupKeyRequest>(Arena*);
	+template<> ::backup::RecoverBackupKeyResponse* Arena::CreateMaybeMessage<::backup::RecoverBackupKeyResponse>(Arena*);
	template<> ::backup::SendLogRequest* Arena::CreateMaybeMessage<::backup::SendLogRequest>(Arena*);
	+template<> ::backup::SimpleAuthenticationRequestData* Arena::CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(Arena*);
	PROTOBUF_NAMESPACE_CLOSE
	namespace backup {

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

	-class ResetKeyRequest PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.ResetKeyRequest) */ {
	+class FullAuthenticationRequestData PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.FullAuthenticationRequestData) */ {
	public:
	- inline ResetKeyRequest() : ResetKeyRequest(nullptr) {}
	- virtual ~ResetKeyRequest();
	- explicit constexpr ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline FullAuthenticationRequestData() : FullAuthenticationRequestData(nullptr) {}
	+ virtual ~FullAuthenticationRequestData();
	+ explicit constexpr FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- ResetKeyRequest(const ResetKeyRequest& from);
	- ResetKeyRequest(ResetKeyRequest&& from) noexcept
	- : ResetKeyRequest() {
	+ FullAuthenticationRequestData(const FullAuthenticationRequestData& from);
	+ FullAuthenticationRequestData(FullAuthenticationRequestData&& from) noexcept
	+ : FullAuthenticationRequestData() {
	*this = ::std::move(from);
	}

	- inline ResetKeyRequest& operator=(const ResetKeyRequest& from) {
	+ inline FullAuthenticationRequestData& operator=(const FullAuthenticationRequestData& from) {
	CopyFrom(from);
	return *this;
	}
	- inline ResetKeyRequest& operator=(ResetKeyRequest&& from) noexcept {
	+ inline FullAuthenticationRequestData& operator=(FullAuthenticationRequestData&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -122,26 +142,30 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const ResetKeyRequest& default_instance() {
	+ static const FullAuthenticationRequestData& default_instance() {
	return *internal_default_instance();
	}
	- enum DataCase {
	- kNewKey = 2,
	- kCompactionChunk = 3,
	- DATA_NOT_SET = 0,
	+ enum RequestBytesCase {
	+ kPakeRegistrationRequest = 1,
	+ kPakeRegistrationUpload = 2,
	+ kPakeCredentialRequest = 3,
	+ kPakeCredentialFinalization = 4,
	+ kPakeChallengeResponse = 5,
	+ kWalletAuthenticationRequest = 6,
	+ REQUESTBYTES_NOT_SET = 0,
	};

	- static inline const ResetKeyRequest* internal_default_instance() {
	- return reinterpret_cast<const ResetKeyRequest*>(
	- &_ResetKeyRequest_default_instance_);
	+ static inline const FullAuthenticationRequestData* internal_default_instance() {
	+ return reinterpret_cast<const FullAuthenticationRequestData*>(
	+ &_FullAuthenticationRequestData_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	0;

	- friend void swap(ResetKeyRequest& a, ResetKeyRequest& b) {
	+ friend void swap(FullAuthenticationRequestData& a, FullAuthenticationRequestData& b) {
	a.Swap(&b);
	}
	- inline void Swap(ResetKeyRequest* other) {
	+ inline void Swap(FullAuthenticationRequestData* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -149,7 +173,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(ResetKeyRequest* other) {
	+ void UnsafeArenaSwap(FullAuthenticationRequestData* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -157,17 +181,17 @@

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

	- inline ResetKeyRequest* New() const final {
	- return CreateMaybeMessage<ResetKeyRequest>(nullptr);
	+ inline FullAuthenticationRequestData* New() const final {
	+ return CreateMaybeMessage<FullAuthenticationRequestData>(nullptr);
	}

	- ResetKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<ResetKeyRequest>(arena);
	+ FullAuthenticationRequestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<FullAuthenticationRequestData>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const ResetKeyRequest& from);
	- void MergeFrom(const ResetKeyRequest& from);
	+ void CopyFrom(const FullAuthenticationRequestData& from);
	+ void MergeFrom(const FullAuthenticationRequestData& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -181,13 +205,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(ResetKeyRequest* other);
	+ void InternalSwap(FullAuthenticationRequestData* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "backup.ResetKeyRequest";
	+ return "backup.FullAuthenticationRequestData";
	}
	protected:
	- explicit ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -206,11 +230,15 @@
	// accessors -------------------------------------------------------

	enum : int {
	- kUserIdFieldNumber = 1,
	- kNewKeyFieldNumber = 2,
	- kCompactionChunkFieldNumber = 3,
	+ kUserIDFieldNumber = 7,
	+ kPakeRegistrationRequestFieldNumber = 1,
	+ kPakeRegistrationUploadFieldNumber = 2,
	+ kPakeCredentialRequestFieldNumber = 3,
	+ kPakeCredentialFinalizationFieldNumber = 4,
	+ kPakeChallengeResponseFieldNumber = 5,
	+ kWalletAuthenticationRequestFieldNumber = 6,
	};
	- // string userId = 1;
	+ // string userID = 7;
	void clear_userid();
	const std::string& userid() const;
	void set_userid(const std::string& value);
	@@ -226,67 +254,155 @@
	std::string* _internal_mutable_userid();
	public:

	- // bytes newKey = 2;
	- bool has_newkey() const;
	+ // bytes pakeRegistrationRequest = 1;
	+ bool has_pakeregistrationrequest() const;
	private:
	- bool _internal_has_newkey() const;
	+ bool _internal_has_pakeregistrationrequest() const;
	public:
	- void clear_newkey();
	- const std::string& newkey() const;
	- void set_newkey(const std::string& value);
	- void set_newkey(std::string&& value);
	- void set_newkey(const char* value);
	- void set_newkey(const void* value, size_t size);
	- std::string* mutable_newkey();
	- std::string* release_newkey();
	- void set_allocated_newkey(std::string* newkey);
	+ void clear_pakeregistrationrequest();
	+ const std::string& pakeregistrationrequest() const;
	+ void set_pakeregistrationrequest(const std::string& value);
	+ void set_pakeregistrationrequest(std::string&& value);
	+ void set_pakeregistrationrequest(const char* value);
	+ void set_pakeregistrationrequest(const void* value, size_t size);
	+ std::string* mutable_pakeregistrationrequest();
	+ std::string* release_pakeregistrationrequest();
	+ void set_allocated_pakeregistrationrequest(std::string* pakeregistrationrequest);
	private:
	- const std::string& _internal_newkey() const;
	- void _internal_set_newkey(const std::string& value);
	- std::string* _internal_mutable_newkey();
	+ const std::string& _internal_pakeregistrationrequest() const;
	+ void _internal_set_pakeregistrationrequest(const std::string& value);
	+ std::string* _internal_mutable_pakeregistrationrequest();
	public:

	- // bytes compactionChunk = 3;
	- bool has_compactionchunk() const;
	+ // bytes pakeRegistrationUpload = 2;
	+ bool has_pakeregistrationupload() const;
	private:
	- bool _internal_has_compactionchunk() const;
	+ bool _internal_has_pakeregistrationupload() const;
	public:
	- void clear_compactionchunk();
	- const std::string& compactionchunk() const;
	- void set_compactionchunk(const std::string& value);
	- void set_compactionchunk(std::string&& value);
	- void set_compactionchunk(const char* value);
	- void set_compactionchunk(const void* value, size_t size);
	- std::string* mutable_compactionchunk();
	- std::string* release_compactionchunk();
	- void set_allocated_compactionchunk(std::string* compactionchunk);
	+ void clear_pakeregistrationupload();
	+ const std::string& pakeregistrationupload() const;
	+ void set_pakeregistrationupload(const std::string& value);
	+ void set_pakeregistrationupload(std::string&& value);
	+ void set_pakeregistrationupload(const char* value);
	+ void set_pakeregistrationupload(const void* value, size_t size);
	+ std::string* mutable_pakeregistrationupload();
	+ std::string* release_pakeregistrationupload();
	+ void set_allocated_pakeregistrationupload(std::string* pakeregistrationupload);
	private:
	- const std::string& _internal_compactionchunk() const;
	- void _internal_set_compactionchunk(const std::string& value);
	- std::string* _internal_mutable_compactionchunk();
	+ const std::string& _internal_pakeregistrationupload() const;
	+ void _internal_set_pakeregistrationupload(const std::string& value);
	+ std::string* _internal_mutable_pakeregistrationupload();
	public:

	- void clear_data();
	- DataCase data_case() const;
	- // @@protoc_insertion_point(class_scope:backup.ResetKeyRequest)
	+ // bytes pakeCredentialRequest = 3;
	+ bool has_pakecredentialrequest() const;
	+ private:
	+ bool _internal_has_pakecredentialrequest() const;
	+ public:
	+ void clear_pakecredentialrequest();
	+ const std::string& pakecredentialrequest() const;
	+ void set_pakecredentialrequest(const std::string& value);
	+ void set_pakecredentialrequest(std::string&& value);
	+ void set_pakecredentialrequest(const char* value);
	+ void set_pakecredentialrequest(const void* value, size_t size);
	+ std::string* mutable_pakecredentialrequest();
	+ std::string* release_pakecredentialrequest();
	+ void set_allocated_pakecredentialrequest(std::string* pakecredentialrequest);
	+ private:
	+ const std::string& _internal_pakecredentialrequest() const;
	+ void _internal_set_pakecredentialrequest(const std::string& value);
	+ std::string* _internal_mutable_pakecredentialrequest();
	+ public:
	+
	+ // bytes pakeCredentialFinalization = 4;
	+ bool has_pakecredentialfinalization() const;
	+ private:
	+ bool _internal_has_pakecredentialfinalization() const;
	+ public:
	+ void clear_pakecredentialfinalization();
	+ const std::string& pakecredentialfinalization() const;
	+ void set_pakecredentialfinalization(const std::string& value);
	+ void set_pakecredentialfinalization(std::string&& value);
	+ void set_pakecredentialfinalization(const char* value);
	+ void set_pakecredentialfinalization(const void* value, size_t size);
	+ std::string* mutable_pakecredentialfinalization();
	+ std::string* release_pakecredentialfinalization();
	+ void set_allocated_pakecredentialfinalization(std::string* pakecredentialfinalization);
	+ private:
	+ const std::string& _internal_pakecredentialfinalization() const;
	+ void _internal_set_pakecredentialfinalization(const std::string& value);
	+ std::string* _internal_mutable_pakecredentialfinalization();
	+ public:
	+
	+ // bytes pakeChallengeResponse = 5;
	+ bool has_pakechallengeresponse() const;
	+ private:
	+ bool _internal_has_pakechallengeresponse() const;
	+ public:
	+ void clear_pakechallengeresponse();
	+ const std::string& pakechallengeresponse() const;
	+ void set_pakechallengeresponse(const std::string& value);
	+ void set_pakechallengeresponse(std::string&& value);
	+ void set_pakechallengeresponse(const char* value);
	+ void set_pakechallengeresponse(const void* value, size_t size);
	+ std::string* mutable_pakechallengeresponse();
	+ std::string* release_pakechallengeresponse();
	+ void set_allocated_pakechallengeresponse(std::string* pakechallengeresponse);
	+ private:
	+ const std::string& _internal_pakechallengeresponse() const;
	+ void _internal_set_pakechallengeresponse(const std::string& value);
	+ std::string* _internal_mutable_pakechallengeresponse();
	+ public:
	+
	+ // bytes walletAuthenticationRequest = 6;
	+ bool has_walletauthenticationrequest() const;
	+ private:
	+ bool _internal_has_walletauthenticationrequest() const;
	+ public:
	+ void clear_walletauthenticationrequest();
	+ const std::string& walletauthenticationrequest() const;
	+ void set_walletauthenticationrequest(const std::string& value);
	+ void set_walletauthenticationrequest(std::string&& value);
	+ void set_walletauthenticationrequest(const char* value);
	+ void set_walletauthenticationrequest(const void* value, size_t size);
	+ std::string* mutable_walletauthenticationrequest();
	+ std::string* release_walletauthenticationrequest();
	+ void set_allocated_walletauthenticationrequest(std::string* walletauthenticationrequest);
	+ private:
	+ const std::string& _internal_walletauthenticationrequest() const;
	+ void _internal_set_walletauthenticationrequest(const std::string& value);
	+ std::string* _internal_mutable_walletauthenticationrequest();
	+ public:
	+
	+ void clear_requestBytes();
	+ RequestBytesCase requestBytes_case() const;
	+ // @@protoc_insertion_point(class_scope:backup.FullAuthenticationRequestData)
	private:
	class _Internal;
	- void set_has_newkey();
	- void set_has_compactionchunk();
	+ void set_has_pakeregistrationrequest();
	+ void set_has_pakeregistrationupload();
	+ void set_has_pakecredentialrequest();
	+ void set_has_pakecredentialfinalization();
	+ void set_has_pakechallengeresponse();
	+ void set_has_walletauthenticationrequest();

	- inline bool has_data() const;
	- inline void clear_has_data();
	+ inline bool has_requestBytes() const;
	+ inline void clear_has_requestBytes();

	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	typedef void InternalArenaConstructable_;
	typedef void DestructorSkippable_;
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
	- union DataUnion {
	- constexpr DataUnion() : _constinit_{} {}
	+ union RequestBytesUnion {
	+ constexpr RequestBytesUnion() : _constinit_{} {}
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newkey_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_;
	- } data_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationrequest_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationupload_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialrequest_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialfinalization_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakechallengeresponse_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr walletauthenticationrequest_;
	+ } requestBytes_;
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

	@@ -294,24 +410,24 @@
	};
	// -------------------------------------------------------------------

	-class SendLogRequest PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SendLogRequest) */ {
	+class FullAuthenticationResponseData PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.FullAuthenticationResponseData) */ {
	public:
	- inline SendLogRequest() : SendLogRequest(nullptr) {}
	- virtual ~SendLogRequest();
	- explicit constexpr SendLogRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline FullAuthenticationResponseData() : FullAuthenticationResponseData(nullptr) {}
	+ virtual ~FullAuthenticationResponseData();
	+ explicit constexpr FullAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- SendLogRequest(const SendLogRequest& from);
	- SendLogRequest(SendLogRequest&& from) noexcept
	- : SendLogRequest() {
	+ FullAuthenticationResponseData(const FullAuthenticationResponseData& from);
	+ FullAuthenticationResponseData(FullAuthenticationResponseData&& from) noexcept
	+ : FullAuthenticationResponseData() {
	*this = ::std::move(from);
	}

	- inline SendLogRequest& operator=(const SendLogRequest& from) {
	+ inline FullAuthenticationResponseData& operator=(const FullAuthenticationResponseData& from) {
	CopyFrom(from);
	return *this;
	}
	- inline SendLogRequest& operator=(SendLogRequest&& from) noexcept {
	+ inline FullAuthenticationResponseData& operator=(FullAuthenticationResponseData&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -329,20 +445,29 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const SendLogRequest& default_instance() {
	+ static const FullAuthenticationResponseData& default_instance() {
	return *internal_default_instance();
	}
	- static inline const SendLogRequest* internal_default_instance() {
	- return reinterpret_cast<const SendLogRequest*>(
	- &_SendLogRequest_default_instance_);
	+ enum ResponseDataCase {
	+ kPakeRegistrationResponse = 1,
	+ kPakeRegistrationSuccess = 2,
	+ kPakeCredentialResponse = 3,
	+ kPakeChallengeMessage = 4,
	+ kWalletAuthenticationResponse = 5,
	+ RESPONSEDATA_NOT_SET = 0,
	+ };
	+
	+ static inline const FullAuthenticationResponseData* internal_default_instance() {
	+ return reinterpret_cast<const FullAuthenticationResponseData*>(
	+ &_FullAuthenticationResponseData_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	1;

	- friend void swap(SendLogRequest& a, SendLogRequest& b) {
	+ friend void swap(FullAuthenticationResponseData& a, FullAuthenticationResponseData& b) {
	a.Swap(&b);
	}
	- inline void Swap(SendLogRequest* other) {
	+ inline void Swap(FullAuthenticationResponseData* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -350,7 +475,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(SendLogRequest* other) {
	+ void UnsafeArenaSwap(FullAuthenticationResponseData* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -358,17 +483,17 @@

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

	- inline SendLogRequest* New() const final {
	- return CreateMaybeMessage<SendLogRequest>(nullptr);
	+ inline FullAuthenticationResponseData* New() const final {
	+ return CreateMaybeMessage<FullAuthenticationResponseData>(nullptr);
	}

	- SendLogRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<SendLogRequest>(arena);
	+ FullAuthenticationResponseData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<FullAuthenticationResponseData>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const SendLogRequest& from);
	- void MergeFrom(const SendLogRequest& from);
	+ void CopyFrom(const FullAuthenticationResponseData& from);
	+ void MergeFrom(const FullAuthenticationResponseData& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -382,13 +507,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(SendLogRequest* other);
	+ void InternalSwap(FullAuthenticationResponseData* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "backup.SendLogRequest";
	+ return "backup.FullAuthenticationResponseData";
	}
	protected:
	- explicit SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit FullAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -407,73 +532,156 @@
	// accessors -------------------------------------------------------

	enum : int {
	- kUserIdFieldNumber = 1,
	- kDataFieldNumber = 2,
	+ kPakeRegistrationResponseFieldNumber = 1,
	+ kPakeRegistrationSuccessFieldNumber = 2,
	+ kPakeCredentialResponseFieldNumber = 3,
	+ kPakeChallengeMessageFieldNumber = 4,
	+ kWalletAuthenticationResponseFieldNumber = 5,
	};
	- // string userId = 1;
	- void clear_userid();
	- const std::string& userid() const;
	- void set_userid(const std::string& value);
	- void set_userid(std::string&& value);
	- void set_userid(const char* value);
	- void set_userid(const char* value, size_t size);
	- std::string* mutable_userid();
	- std::string* release_userid();
	- void set_allocated_userid(std::string* userid);
	+ // bytes pakeRegistrationResponse = 1;
	+ bool has_pakeregistrationresponse() const;
	private:
	- const std::string& _internal_userid() const;
	- void _internal_set_userid(const std::string& value);
	- std::string* _internal_mutable_userid();
	+ bool _internal_has_pakeregistrationresponse() const;
	+ public:
	+ void clear_pakeregistrationresponse();
	+ const std::string& pakeregistrationresponse() const;
	+ void set_pakeregistrationresponse(const std::string& value);
	+ void set_pakeregistrationresponse(std::string&& value);
	+ void set_pakeregistrationresponse(const char* value);
	+ void set_pakeregistrationresponse(const void* value, size_t size);
	+ std::string* mutable_pakeregistrationresponse();
	+ std::string* release_pakeregistrationresponse();
	+ void set_allocated_pakeregistrationresponse(std::string* pakeregistrationresponse);
	+ private:
	+ const std::string& _internal_pakeregistrationresponse() const;
	+ void _internal_set_pakeregistrationresponse(const std::string& value);
	+ std::string* _internal_mutable_pakeregistrationresponse();
	public:

	- // bytes data = 2;
	- void clear_data();
	- const std::string& data() const;
	- void set_data(const std::string& value);
	- void set_data(std::string&& value);
	- void set_data(const char* value);
	- void set_data(const void* value, size_t size);
	- std::string* mutable_data();
	- std::string* release_data();
	- void set_allocated_data(std::string* data);
	+ // bool pakeRegistrationSuccess = 2;
	+ bool has_pakeregistrationsuccess() const;
	private:
	- const std::string& _internal_data() const;
	- void _internal_set_data(const std::string& value);
	- std::string* _internal_mutable_data();
	+ bool _internal_has_pakeregistrationsuccess() const;
	+ public:
	+ void clear_pakeregistrationsuccess();
	+ bool pakeregistrationsuccess() const;
	+ void set_pakeregistrationsuccess(bool value);
	+ private:
	+ bool _internal_pakeregistrationsuccess() const;
	+ void _internal_set_pakeregistrationsuccess(bool value);
	public:

	- // @@protoc_insertion_point(class_scope:backup.SendLogRequest)
	+ // bytes pakeCredentialResponse = 3;
	+ bool has_pakecredentialresponse() const;
	+ private:
	+ bool _internal_has_pakecredentialresponse() const;
	+ public:
	+ void clear_pakecredentialresponse();
	+ const std::string& pakecredentialresponse() const;
	+ void set_pakecredentialresponse(const std::string& value);
	+ void set_pakecredentialresponse(std::string&& value);
	+ void set_pakecredentialresponse(const char* value);
	+ void set_pakecredentialresponse(const void* value, size_t size);
	+ std::string* mutable_pakecredentialresponse();
	+ std::string* release_pakecredentialresponse();
	+ void set_allocated_pakecredentialresponse(std::string* pakecredentialresponse);
	+ private:
	+ const std::string& _internal_pakecredentialresponse() const;
	+ void _internal_set_pakecredentialresponse(const std::string& value);
	+ std::string* _internal_mutable_pakecredentialresponse();
	+ public:
	+
	+ // bytes pakeChallengeMessage = 4;
	+ bool has_pakechallengemessage() const;
	+ private:
	+ bool _internal_has_pakechallengemessage() const;
	+ public:
	+ void clear_pakechallengemessage();
	+ const std::string& pakechallengemessage() const;
	+ void set_pakechallengemessage(const std::string& value);
	+ void set_pakechallengemessage(std::string&& value);
	+ void set_pakechallengemessage(const char* value);
	+ void set_pakechallengemessage(const void* value, size_t size);
	+ std::string* mutable_pakechallengemessage();
	+ std::string* release_pakechallengemessage();
	+ void set_allocated_pakechallengemessage(std::string* pakechallengemessage);
	+ private:
	+ const std::string& _internal_pakechallengemessage() const;
	+ void _internal_set_pakechallengemessage(const std::string& value);
	+ std::string* _internal_mutable_pakechallengemessage();
	+ public:
	+
	+ // bytes walletAuthenticationResponse = 5;
	+ bool has_walletauthenticationresponse() const;
	+ private:
	+ bool _internal_has_walletauthenticationresponse() const;
	+ public:
	+ void clear_walletauthenticationresponse();
	+ const std::string& walletauthenticationresponse() const;
	+ void set_walletauthenticationresponse(const std::string& value);
	+ void set_walletauthenticationresponse(std::string&& value);
	+ void set_walletauthenticationresponse(const char* value);
	+ void set_walletauthenticationresponse(const void* value, size_t size);
	+ std::string* mutable_walletauthenticationresponse();
	+ std::string* release_walletauthenticationresponse();
	+ void set_allocated_walletauthenticationresponse(std::string* walletauthenticationresponse);
	+ private:
	+ const std::string& _internal_walletauthenticationresponse() const;
	+ void _internal_set_walletauthenticationresponse(const std::string& value);
	+ std::string* _internal_mutable_walletauthenticationresponse();
	+ public:
	+
	+ void clear_responseData();
	+ ResponseDataCase responseData_case() const;
	+ // @@protoc_insertion_point(class_scope:backup.FullAuthenticationResponseData)
	private:
	class _Internal;
	+ void set_has_pakeregistrationresponse();
	+ void set_has_pakeregistrationsuccess();
	+ void set_has_pakecredentialresponse();
	+ void set_has_pakechallengemessage();
	+ void set_has_walletauthenticationresponse();
	+
	+ inline bool has_responseData() const;
	+ inline void clear_has_responseData();

	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	typedef void InternalArenaConstructable_;
	typedef void DestructorSkippable_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
	+ union ResponseDataUnion {
	+ constexpr ResponseDataUnion() : _constinit_{} {}
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationresponse_;
	+ bool pakeregistrationsuccess_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialresponse_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakechallengemessage_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr walletauthenticationresponse_;
	+ } responseData_;
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	friend struct ::TableStruct_backup_2eproto;
	};
	// -------------------------------------------------------------------

	-class PullBackupKeyRequest PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupKeyRequest) */ {
	+class SimpleAuthenticationRequestData PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SimpleAuthenticationRequestData) */ {
	public:
	- inline PullBackupKeyRequest() : PullBackupKeyRequest(nullptr) {}
	- virtual ~PullBackupKeyRequest();
	- explicit constexpr PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline SimpleAuthenticationRequestData() : SimpleAuthenticationRequestData(nullptr) {}
	+ virtual ~SimpleAuthenticationRequestData();
	+ explicit constexpr SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- PullBackupKeyRequest(const PullBackupKeyRequest& from);
	- PullBackupKeyRequest(PullBackupKeyRequest&& from) noexcept
	- : PullBackupKeyRequest() {
	+ SimpleAuthenticationRequestData(const SimpleAuthenticationRequestData& from);
	+ SimpleAuthenticationRequestData(SimpleAuthenticationRequestData&& from) noexcept
	+ : SimpleAuthenticationRequestData() {
	*this = ::std::move(from);
	}

	- inline PullBackupKeyRequest& operator=(const PullBackupKeyRequest& from) {
	+ inline SimpleAuthenticationRequestData& operator=(const SimpleAuthenticationRequestData& from) {
	CopyFrom(from);
	return *this;
	}
	- inline PullBackupKeyRequest& operator=(PullBackupKeyRequest&& from) noexcept {
	+ inline SimpleAuthenticationRequestData& operator=(SimpleAuthenticationRequestData&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -491,20 +699,20 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const PullBackupKeyRequest& default_instance() {
	+ static const SimpleAuthenticationRequestData& default_instance() {
	return *internal_default_instance();
	}
	- static inline const PullBackupKeyRequest* internal_default_instance() {
	- return reinterpret_cast<const PullBackupKeyRequest*>(
	- &_PullBackupKeyRequest_default_instance_);
	+ static inline const SimpleAuthenticationRequestData* internal_default_instance() {
	+ return reinterpret_cast<const SimpleAuthenticationRequestData*>(
	+ &_SimpleAuthenticationRequestData_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	2;

	- friend void swap(PullBackupKeyRequest& a, PullBackupKeyRequest& b) {
	+ friend void swap(SimpleAuthenticationRequestData& a, SimpleAuthenticationRequestData& b) {
	a.Swap(&b);
	}
	- inline void Swap(PullBackupKeyRequest* other) {
	+ inline void Swap(SimpleAuthenticationRequestData* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -512,7 +720,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(PullBackupKeyRequest* other) {
	+ void UnsafeArenaSwap(SimpleAuthenticationRequestData* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -520,17 +728,17 @@

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

	- inline PullBackupKeyRequest* New() const final {
	- return CreateMaybeMessage<PullBackupKeyRequest>(nullptr);
	+ inline SimpleAuthenticationRequestData* New() const final {
	+ return CreateMaybeMessage<SimpleAuthenticationRequestData>(nullptr);
	}

	- PullBackupKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<PullBackupKeyRequest>(arena);
	+ SimpleAuthenticationRequestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<SimpleAuthenticationRequestData>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const PullBackupKeyRequest& from);
	- void MergeFrom(const PullBackupKeyRequest& from);
	+ void CopyFrom(const SimpleAuthenticationRequestData& from);
	+ void MergeFrom(const SimpleAuthenticationRequestData& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -544,13 +752,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(PullBackupKeyRequest* other);
	+ void InternalSwap(SimpleAuthenticationRequestData* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "backup.PullBackupKeyRequest";
	+ return "backup.SimpleAuthenticationRequestData";
	}
	protected:
	- explicit PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -569,10 +777,26 @@
	// accessors -------------------------------------------------------

	enum : int {
	- kUserIdFieldNumber = 1,
	- kPakeKeyFieldNumber = 2,
	+ kBackupIDFieldNumber = 1,
	+ kUserIDFieldNumber = 2,
	};
	- // string userId = 1;
	+ // string backupID = 1;
	+ void clear_backupid();
	+ const std::string& backupid() const;
	+ void set_backupid(const std::string& value);
	+ void set_backupid(std::string&& value);
	+ void set_backupid(const char* value);
	+ void set_backupid(const char* value, size_t size);
	+ std::string* mutable_backupid();
	+ std::string* release_backupid();
	+ void set_allocated_backupid(std::string* backupid);
	+ private:
	+ const std::string& _internal_backupid() const;
	+ void _internal_set_backupid(const std::string& value);
	+ std::string* _internal_mutable_backupid();
	+ public:
	+
	+ // string userID = 2;
	void clear_userid();
	const std::string& userid() const;
	void set_userid(const std::string& value);
	@@ -588,54 +812,38 @@
	std::string* _internal_mutable_userid();
	public:

	- // bytes pakeKey = 2;
	- void clear_pakekey();
	- const std::string& pakekey() const;
	- void set_pakekey(const std::string& value);
	- void set_pakekey(std::string&& value);
	- void set_pakekey(const char* value);
	- void set_pakekey(const void* value, size_t size);
	- std::string* mutable_pakekey();
	- std::string* release_pakekey();
	- void set_allocated_pakekey(std::string* pakekey);
	- private:
	- const std::string& _internal_pakekey() const;
	- void _internal_set_pakekey(const std::string& value);
	- std::string* _internal_mutable_pakekey();
	- public:
	-
	- // @@protoc_insertion_point(class_scope:backup.PullBackupKeyRequest)
	+ // @@protoc_insertion_point(class_scope:backup.SimpleAuthenticationRequestData)
	private:
	class _Internal;

	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	typedef void InternalArenaConstructable_;
	typedef void DestructorSkippable_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_;
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakekey_;
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	friend struct ::TableStruct_backup_2eproto;
	};
	// -------------------------------------------------------------------

	-class PullBackupKeyResponse PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupKeyResponse) */ {
	+class AuthenticationInformationData PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.AuthenticationInformationData) */ {
	public:
	- inline PullBackupKeyResponse() : PullBackupKeyResponse(nullptr) {}
	- virtual ~PullBackupKeyResponse();
	- explicit constexpr PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline AuthenticationInformationData() : AuthenticationInformationData(nullptr) {}
	+ virtual ~AuthenticationInformationData();
	+ explicit constexpr AuthenticationInformationData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- PullBackupKeyResponse(const PullBackupKeyResponse& from);
	- PullBackupKeyResponse(PullBackupKeyResponse&& from) noexcept
	- : PullBackupKeyResponse() {
	+ AuthenticationInformationData(const AuthenticationInformationData& from);
	+ AuthenticationInformationData(AuthenticationInformationData&& from) noexcept
	+ : AuthenticationInformationData() {
	*this = ::std::move(from);
	}

	- inline PullBackupKeyResponse& operator=(const PullBackupKeyResponse& from) {
	+ inline AuthenticationInformationData& operator=(const AuthenticationInformationData& from) {
	CopyFrom(from);
	return *this;
	}
	- inline PullBackupKeyResponse& operator=(PullBackupKeyResponse&& from) noexcept {
	+ inline AuthenticationInformationData& operator=(AuthenticationInformationData&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -653,20 +861,26 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const PullBackupKeyResponse& default_instance() {
	+ static const AuthenticationInformationData& default_instance() {
	return *internal_default_instance();
	}
	- static inline const PullBackupKeyResponse* internal_default_instance() {
	- return reinterpret_cast<const PullBackupKeyResponse*>(
	- &_PullBackupKeyResponse_default_instance_);
	+ enum DataCase {
	+ kNonce = 1,
	+ kRawMessage = 2,
	+ DATA_NOT_SET = 0,
	+ };
	+
	+ static inline const AuthenticationInformationData* internal_default_instance() {
	+ return reinterpret_cast<const AuthenticationInformationData*>(
	+ &_AuthenticationInformationData_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	3;

	- friend void swap(PullBackupKeyResponse& a, PullBackupKeyResponse& b) {
	+ friend void swap(AuthenticationInformationData& a, AuthenticationInformationData& b) {
	a.Swap(&b);
	}
	- inline void Swap(PullBackupKeyResponse* other) {
	+ inline void Swap(AuthenticationInformationData* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -674,7 +888,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(PullBackupKeyResponse* other) {
	+ void UnsafeArenaSwap(AuthenticationInformationData* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -682,17 +896,17 @@

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

	- inline PullBackupKeyResponse* New() const final {
	- return CreateMaybeMessage<PullBackupKeyResponse>(nullptr);
	+ inline AuthenticationInformationData* New() const final {
	+ return CreateMaybeMessage<AuthenticationInformationData>(nullptr);
	}

	- PullBackupKeyResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<PullBackupKeyResponse>(arena);
	+ AuthenticationInformationData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<AuthenticationInformationData>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const PullBackupKeyResponse& from);
	- void MergeFrom(const PullBackupKeyResponse& from);
	+ void CopyFrom(const AuthenticationInformationData& from);
	+ void MergeFrom(const AuthenticationInformationData& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -706,13 +920,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(PullBackupKeyResponse* other);
	+ void InternalSwap(AuthenticationInformationData* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "backup.PullBackupKeyResponse";
	+ return "backup.AuthenticationInformationData";
	}
	protected:
	- explicit PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit AuthenticationInformationData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -731,55 +945,94 @@
	// accessors -------------------------------------------------------

	enum : int {
	- kEncryptedBackupKeyFieldNumber = 1,
	+ kNonceFieldNumber = 1,
	+ kRawMessageFieldNumber = 2,
	};
	- // bytes encryptedBackupKey = 1;
	- void clear_encryptedbackupkey();
	- const std::string& encryptedbackupkey() const;
	- void set_encryptedbackupkey(const std::string& value);
	- void set_encryptedbackupkey(std::string&& value);
	- void set_encryptedbackupkey(const char* value);
	- void set_encryptedbackupkey(const void* value, size_t size);
	- std::string* mutable_encryptedbackupkey();
	- std::string* release_encryptedbackupkey();
	- void set_allocated_encryptedbackupkey(std::string* encryptedbackupkey);
	- private:
	- const std::string& _internal_encryptedbackupkey() const;
	- void _internal_set_encryptedbackupkey(const std::string& value);
	- std::string* _internal_mutable_encryptedbackupkey();
	- public:
	-
	- // @@protoc_insertion_point(class_scope:backup.PullBackupKeyResponse)
	+ // bytes nonce = 1;
	+ bool has_nonce() const;
	+ private:
	+ bool _internal_has_nonce() const;
	+ public:
	+ void clear_nonce();
	+ const std::string& nonce() const;
	+ void set_nonce(const std::string& value);
	+ void set_nonce(std::string&& value);
	+ void set_nonce(const char* value);
	+ void set_nonce(const void* value, size_t size);
	+ std::string* mutable_nonce();
	+ std::string* release_nonce();
	+ void set_allocated_nonce(std::string* nonce);
	+ private:
	+ const std::string& _internal_nonce() const;
	+ void _internal_set_nonce(const std::string& value);
	+ std::string* _internal_mutable_nonce();
	+ public:
	+
	+ // bytes rawMessage = 2;
	+ bool has_rawmessage() const;
	+ private:
	+ bool _internal_has_rawmessage() const;
	+ public:
	+ void clear_rawmessage();
	+ const std::string& rawmessage() const;
	+ void set_rawmessage(const std::string& value);
	+ void set_rawmessage(std::string&& value);
	+ void set_rawmessage(const char* value);
	+ void set_rawmessage(const void* value, size_t size);
	+ std::string* mutable_rawmessage();
	+ std::string* release_rawmessage();
	+ void set_allocated_rawmessage(std::string* rawmessage);
	+ private:
	+ const std::string& _internal_rawmessage() const;
	+ void _internal_set_rawmessage(const std::string& value);
	+ std::string* _internal_mutable_rawmessage();
	+ public:
	+
	+ void clear_data();
	+ DataCase data_case() const;
	+ // @@protoc_insertion_point(class_scope:backup.AuthenticationInformationData)
	private:
	class _Internal;
	+ void set_has_nonce();
	+ void set_has_rawmessage();
	+
	+ inline bool has_data() const;
	+ inline void clear_has_data();

	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	typedef void InternalArenaConstructable_;
	typedef void DestructorSkippable_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryptedbackupkey_;
	+ union DataUnion {
	+ constexpr DataUnion() : _constinit_{} {}
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nonce_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rawmessage_;
	+ } data_;
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	friend struct ::TableStruct_backup_2eproto;
	};
	// -------------------------------------------------------------------

	-class PullCompactionRequest PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullCompactionRequest) */ {
	+class CreateNewBackupRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.CreateNewBackupRequest) */ {
	public:
	- inline PullCompactionRequest() : PullCompactionRequest(nullptr) {}
	- virtual ~PullCompactionRequest();
	- explicit constexpr PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline CreateNewBackupRequest() : CreateNewBackupRequest(nullptr) {}
	+ virtual ~CreateNewBackupRequest();
	+ explicit constexpr CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- PullCompactionRequest(const PullCompactionRequest& from);
	- PullCompactionRequest(PullCompactionRequest&& from) noexcept
	- : PullCompactionRequest() {
	+ CreateNewBackupRequest(const CreateNewBackupRequest& from);
	+ CreateNewBackupRequest(CreateNewBackupRequest&& from) noexcept
	+ : CreateNewBackupRequest() {
	*this = ::std::move(from);
	}

	- inline PullCompactionRequest& operator=(const PullCompactionRequest& from) {
	+ inline CreateNewBackupRequest& operator=(const CreateNewBackupRequest& from) {
	CopyFrom(from);
	return *this;
	}
	- inline PullCompactionRequest& operator=(PullCompactionRequest&& from) noexcept {
	+ inline CreateNewBackupRequest& operator=(CreateNewBackupRequest&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -797,20 +1050,27 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const PullCompactionRequest& default_instance() {
	+ static const CreateNewBackupRequest& default_instance() {
	return *internal_default_instance();
	}
	- static inline const PullCompactionRequest* internal_default_instance() {
	- return reinterpret_cast<const PullCompactionRequest*>(
	- &_PullCompactionRequest_default_instance_);
	+ enum DataCase {
	+ kAuthenticationRequestData = 1,
	+ kAuthenticationInformationData = 2,
	+ kNewCompactionChunk = 3,
	+ DATA_NOT_SET = 0,
	+ };
	+
	+ static inline const CreateNewBackupRequest* internal_default_instance() {
	+ return reinterpret_cast<const CreateNewBackupRequest*>(
	+ &_CreateNewBackupRequest_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	4;

	- friend void swap(PullCompactionRequest& a, PullCompactionRequest& b) {
	+ friend void swap(CreateNewBackupRequest& a, CreateNewBackupRequest& b) {
	a.Swap(&b);
	}
	- inline void Swap(PullCompactionRequest* other) {
	+ inline void Swap(CreateNewBackupRequest* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -818,7 +1078,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(PullCompactionRequest* other) {
	+ void UnsafeArenaSwap(CreateNewBackupRequest* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -826,17 +1086,17 @@

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

	- inline PullCompactionRequest* New() const final {
	- return CreateMaybeMessage<PullCompactionRequest>(nullptr);
	+ inline CreateNewBackupRequest* New() const final {
	+ return CreateMaybeMessage<CreateNewBackupRequest>(nullptr);
	}

	- PullCompactionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<PullCompactionRequest>(arena);
	+ CreateNewBackupRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<CreateNewBackupRequest>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const PullCompactionRequest& from);
	- void MergeFrom(const PullCompactionRequest& from);
	+ void CopyFrom(const CreateNewBackupRequest& from);
	+ void MergeFrom(const CreateNewBackupRequest& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -850,13 +1110,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(PullCompactionRequest* other);
	+ void InternalSwap(CreateNewBackupRequest* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "backup.PullCompactionRequest";
	+ return "backup.CreateNewBackupRequest";
	}
	protected:
	- explicit PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -875,73 +1135,113 @@
	// accessors -------------------------------------------------------

	enum : int {
	- kUserIdFieldNumber = 1,
	- kMessageFieldNumber = 2,
	+ kAuthenticationRequestDataFieldNumber = 1,
	+ kAuthenticationInformationDataFieldNumber = 2,
	+ kNewCompactionChunkFieldNumber = 3,
	};
	- // string userId = 1;
	- void clear_userid();
	- const std::string& userid() const;
	- void set_userid(const std::string& value);
	- void set_userid(std::string&& value);
	- void set_userid(const char* value);
	- void set_userid(const char* value, size_t size);
	- std::string* mutable_userid();
	- std::string* release_userid();
	- void set_allocated_userid(std::string* userid);
	+ // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
	+ bool has_authenticationrequestdata() const;
	private:
	- const std::string& _internal_userid() const;
	- void _internal_set_userid(const std::string& value);
	- std::string* _internal_mutable_userid();
	+ bool _internal_has_authenticationrequestdata() const;
	+ public:
	+ void clear_authenticationrequestdata();
	+ const ::backup::FullAuthenticationRequestData& authenticationrequestdata() const;
	+ ::backup::FullAuthenticationRequestData* release_authenticationrequestdata();
	+ ::backup::FullAuthenticationRequestData* mutable_authenticationrequestdata();
	+ void set_allocated_authenticationrequestdata(::backup::FullAuthenticationRequestData* authenticationrequestdata);
	+ private:
	+ const ::backup::FullAuthenticationRequestData& _internal_authenticationrequestdata() const;
	+ ::backup::FullAuthenticationRequestData* _internal_mutable_authenticationrequestdata();
	public:
	+ void unsafe_arena_set_allocated_authenticationrequestdata(
	+ ::backup::FullAuthenticationRequestData* authenticationrequestdata);
	+ ::backup::FullAuthenticationRequestData* unsafe_arena_release_authenticationrequestdata();

	- // bytes message = 2;
	- void clear_message();
	- const std::string& message() const;
	- void set_message(const std::string& value);
	- void set_message(std::string&& value);
	- void set_message(const char* value);
	- void set_message(const void* value, size_t size);
	- std::string* mutable_message();
	- std::string* release_message();
	- void set_allocated_message(std::string* message);
	+ // .backup.AuthenticationInformationData authenticationInformationData = 2;
	+ bool has_authenticationinformationdata() const;
	private:
	- const std::string& _internal_message() const;
	- void _internal_set_message(const std::string& value);
	- std::string* _internal_mutable_message();
	+ bool _internal_has_authenticationinformationdata() const;
	+ public:
	+ void clear_authenticationinformationdata();
	+ const ::backup::AuthenticationInformationData& authenticationinformationdata() const;
	+ ::backup::AuthenticationInformationData* release_authenticationinformationdata();
	+ ::backup::AuthenticationInformationData* mutable_authenticationinformationdata();
	+ void set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata);
	+ private:
	+ const ::backup::AuthenticationInformationData& _internal_authenticationinformationdata() const;
	+ ::backup::AuthenticationInformationData* _internal_mutable_authenticationinformationdata();
	+ public:
	+ void unsafe_arena_set_allocated_authenticationinformationdata(
	+ ::backup::AuthenticationInformationData* authenticationinformationdata);
	+ ::backup::AuthenticationInformationData* unsafe_arena_release_authenticationinformationdata();
	+
	+ // bytes newCompactionChunk = 3;
	+ bool has_newcompactionchunk() const;
	+ private:
	+ bool _internal_has_newcompactionchunk() const;
	+ public:
	+ void clear_newcompactionchunk();
	+ const std::string& newcompactionchunk() const;
	+ void set_newcompactionchunk(const std::string& value);
	+ void set_newcompactionchunk(std::string&& value);
	+ void set_newcompactionchunk(const char* value);
	+ void set_newcompactionchunk(const void* value, size_t size);
	+ std::string* mutable_newcompactionchunk();
	+ std::string* release_newcompactionchunk();
	+ void set_allocated_newcompactionchunk(std::string* newcompactionchunk);
	+ private:
	+ const std::string& _internal_newcompactionchunk() const;
	+ void _internal_set_newcompactionchunk(const std::string& value);
	+ std::string* _internal_mutable_newcompactionchunk();
	public:

	- // @@protoc_insertion_point(class_scope:backup.PullCompactionRequest)
	+ void clear_data();
	+ DataCase data_case() const;
	+ // @@protoc_insertion_point(class_scope:backup.CreateNewBackupRequest)
	private:
	class _Internal;
	+ void set_has_authenticationrequestdata();
	+ void set_has_authenticationinformationdata();
	+ void set_has_newcompactionchunk();
	+
	+ inline bool has_data() const;
	+ inline void clear_has_data();

	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	typedef void InternalArenaConstructable_;
	typedef void DestructorSkippable_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
	+ union DataUnion {
	+ constexpr DataUnion() : _constinit_{} {}
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
	+ ::backup::FullAuthenticationRequestData* authenticationrequestdata_;
	+ ::backup::AuthenticationInformationData* authenticationinformationdata_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newcompactionchunk_;
	+ } data_;
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	friend struct ::TableStruct_backup_2eproto;
	};
	// -------------------------------------------------------------------

	-class PullCompactionResponse PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullCompactionResponse) */ {
	+class CreateNewBackupResponse PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.CreateNewBackupResponse) */ {
	public:
	- inline PullCompactionResponse() : PullCompactionResponse(nullptr) {}
	- virtual ~PullCompactionResponse();
	- explicit constexpr PullCompactionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline CreateNewBackupResponse() : CreateNewBackupResponse(nullptr) {}
	+ virtual ~CreateNewBackupResponse();
	+ explicit constexpr CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- PullCompactionResponse(const PullCompactionResponse& from);
	- PullCompactionResponse(PullCompactionResponse&& from) noexcept
	- : PullCompactionResponse() {
	+ CreateNewBackupResponse(const CreateNewBackupResponse& from);
	+ CreateNewBackupResponse(CreateNewBackupResponse&& from) noexcept
	+ : CreateNewBackupResponse() {
	*this = ::std::move(from);
	}

	- inline PullCompactionResponse& operator=(const PullCompactionResponse& from) {
	+ inline CreateNewBackupResponse& operator=(const CreateNewBackupResponse& from) {
	CopyFrom(from);
	return *this;
	}
	- inline PullCompactionResponse& operator=(PullCompactionResponse&& from) noexcept {
	+ inline CreateNewBackupResponse& operator=(CreateNewBackupResponse&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -959,26 +1259,26 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const PullCompactionResponse& default_instance() {
	+ static const CreateNewBackupResponse& default_instance() {
	return *internal_default_instance();
	}
	enum DataCase {
	- kCompactionChunk = 1,
	- kLogChunk = 2,
	+ kAuthenticationResponseData = 1,
	+ kBackupID = 2,
	DATA_NOT_SET = 0,
	};

	- static inline const PullCompactionResponse* internal_default_instance() {
	- return reinterpret_cast<const PullCompactionResponse*>(
	- &_PullCompactionResponse_default_instance_);
	+ static inline const CreateNewBackupResponse* internal_default_instance() {
	+ return reinterpret_cast<const CreateNewBackupResponse*>(
	+ &_CreateNewBackupResponse_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	5;

	- friend void swap(PullCompactionResponse& a, PullCompactionResponse& b) {
	+ friend void swap(CreateNewBackupResponse& a, CreateNewBackupResponse& b) {
	a.Swap(&b);
	}
	- inline void Swap(PullCompactionResponse* other) {
	+ inline void Swap(CreateNewBackupResponse* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -986,7 +1286,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(PullCompactionResponse* other) {
	+ void UnsafeArenaSwap(CreateNewBackupResponse* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -994,17 +1294,17 @@

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

	- inline PullCompactionResponse* New() const final {
	- return CreateMaybeMessage<PullCompactionResponse>(nullptr);
	+ inline CreateNewBackupResponse* New() const final {
	+ return CreateMaybeMessage<CreateNewBackupResponse>(nullptr);
	}

	- PullCompactionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<PullCompactionResponse>(arena);
	+ CreateNewBackupResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<CreateNewBackupResponse>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const PullCompactionResponse& from);
	- void MergeFrom(const PullCompactionResponse& from);
	+ void CopyFrom(const CreateNewBackupResponse& from);
	+ void MergeFrom(const CreateNewBackupResponse& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -1018,13 +1318,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(PullCompactionResponse* other);
	+ void InternalSwap(CreateNewBackupResponse* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "backup.PullCompactionResponse";
	+ return "backup.CreateNewBackupResponse";
	}
	protected:
	- explicit PullCompactionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -1043,56 +1343,54 @@
	// accessors -------------------------------------------------------

	enum : int {
	- kCompactionChunkFieldNumber = 1,
	- kLogChunkFieldNumber = 2,
	+ kAuthenticationResponseDataFieldNumber = 1,
	+ kBackupIDFieldNumber = 2,
	};
	- // bytes compactionChunk = 1;
	- bool has_compactionchunk() const;
	+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
	+ bool has_authenticationresponsedata() const;
	private:
	- bool _internal_has_compactionchunk() const;
	+ bool _internal_has_authenticationresponsedata() const;
	public:
	- void clear_compactionchunk();
	- const std::string& compactionchunk() const;
	- void set_compactionchunk(const std::string& value);
	- void set_compactionchunk(std::string&& value);
	- void set_compactionchunk(const char* value);
	- void set_compactionchunk(const void* value, size_t size);
	- std::string* mutable_compactionchunk();
	- std::string* release_compactionchunk();
	- void set_allocated_compactionchunk(std::string* compactionchunk);
	+ void clear_authenticationresponsedata();
	+ const ::backup::FullAuthenticationResponseData& authenticationresponsedata() const;
	+ ::backup::FullAuthenticationResponseData* release_authenticationresponsedata();
	+ ::backup::FullAuthenticationResponseData* mutable_authenticationresponsedata();
	+ void set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata);
	private:
	- const std::string& _internal_compactionchunk() const;
	- void _internal_set_compactionchunk(const std::string& value);
	- std::string* _internal_mutable_compactionchunk();
	+ const ::backup::FullAuthenticationResponseData& _internal_authenticationresponsedata() const;
	+ ::backup::FullAuthenticationResponseData* _internal_mutable_authenticationresponsedata();
	public:
	+ void unsafe_arena_set_allocated_authenticationresponsedata(
	+ ::backup::FullAuthenticationResponseData* authenticationresponsedata);
	+ ::backup::FullAuthenticationResponseData* unsafe_arena_release_authenticationresponsedata();

	- // bytes logChunk = 2;
	- bool has_logchunk() const;
	+ // string backupID = 2;
	+ bool has_backupid() const;
	private:
	- bool _internal_has_logchunk() const;
	+ bool _internal_has_backupid() const;
	public:
	- void clear_logchunk();
	- const std::string& logchunk() const;
	- void set_logchunk(const std::string& value);
	- void set_logchunk(std::string&& value);
	- void set_logchunk(const char* value);
	- void set_logchunk(const void* value, size_t size);
	- std::string* mutable_logchunk();
	- std::string* release_logchunk();
	- void set_allocated_logchunk(std::string* logchunk);
	+ void clear_backupid();
	+ const std::string& backupid() const;
	+ void set_backupid(const std::string& value);
	+ void set_backupid(std::string&& value);
	+ void set_backupid(const char* value);
	+ void set_backupid(const char* value, size_t size);
	+ std::string* mutable_backupid();
	+ std::string* release_backupid();
	+ void set_allocated_backupid(std::string* backupid);
	private:
	- const std::string& _internal_logchunk() const;
	- void _internal_set_logchunk(const std::string& value);
	- std::string* _internal_mutable_logchunk();
	+ const std::string& _internal_backupid() const;
	+ void _internal_set_backupid(const std::string& value);
	+ std::string* _internal_mutable_backupid();
	public:

	void clear_data();
	DataCase data_case() const;
	- // @@protoc_insertion_point(class_scope:backup.PullCompactionResponse)
	+ // @@protoc_insertion_point(class_scope:backup.CreateNewBackupResponse)
	private:
	class _Internal;
	- void set_has_compactionchunk();
	- void set_has_logchunk();
	+ void set_has_authenticationresponsedata();
	+ void set_has_backupid();

	inline bool has_data() const;
	inline void clear_has_data();
	@@ -1103,76 +1401,2216 @@
	union DataUnion {
	constexpr DataUnion() : _constinit_{} {}
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logchunk_;
	+ ::backup::FullAuthenticationResponseData* authenticationresponsedata_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_;
	} data_;
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

	friend struct ::TableStruct_backup_2eproto;
	};
	-// ===================================================================
	+// -------------------------------------------------------------------

	+class SendLogRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SendLogRequest) */ {
	+ public:
	+ inline SendLogRequest() : SendLogRequest(nullptr) {}
	+ virtual ~SendLogRequest();
	+ explicit constexpr SendLogRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	-// ===================================================================
	+ SendLogRequest(const SendLogRequest& from);
	+ SendLogRequest(SendLogRequest&& from) noexcept
	+ : SendLogRequest() {
	+ *this = ::std::move(from);
	+ }

	-#ifdef __GNUC__
	- #pragma GCC diagnostic push
	- #pragma GCC diagnostic ignored "-Wstrict-aliasing"
	-#endif // __GNUC__
	-// ResetKeyRequest
	+ inline SendLogRequest& operator=(const SendLogRequest& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline SendLogRequest& operator=(SendLogRequest&& from) noexcept {
	+ if (GetArena() == from.GetArena()) {
	+ if (this != &from) InternalSwap(&from);
	+ } else {
	+ CopyFrom(from);
	+ }
	+ return *this;
	+ }

	-// string userId = 1;
	-inline void ResetKeyRequest::clear_userid() {
	- userid_.ClearToEmpty();
	-}
	-inline const std::string& ResetKeyRequest::userid() const {
	- // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.userId)
	- return _internal_userid();
	-}
	-inline void ResetKeyRequest::set_userid(const std::string& value) {
	- _internal_set_userid(value);
	- // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.userId)
	-}
	-inline std::string* ResetKeyRequest::mutable_userid() {
	- // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.userId)
	- return _internal_mutable_userid();
	-}
	-inline const std::string& ResetKeyRequest::_internal_userid() const {
	- return userid_.Get();
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
	+ return GetDescriptor();
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
	+ return GetMetadataStatic().descriptor;
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	+ return GetMetadataStatic().reflection;
	+ }
	+ static const SendLogRequest& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const SendLogRequest* internal_default_instance() {
	+ return reinterpret_cast<const SendLogRequest*>(
	+ &_SendLogRequest_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 6;
	+
	+ friend void swap(SendLogRequest& a, SendLogRequest& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(SendLogRequest* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(SendLogRequest* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline SendLogRequest* New() const final {
	+ return CreateMaybeMessage<SendLogRequest>(nullptr);
	+ }
	+
	+ SendLogRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<SendLogRequest>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const SendLogRequest& from);
	+ void MergeFrom(const SendLogRequest& from);
	+ 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;
	+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
	+ int GetCachedSize() const final { return _cached_size_.Get(); }
	+
	+ private:
	+ inline void SharedCtor();
	+ inline void SharedDtor();
	+ void SetCachedSize(int size) const final;
	+ void InternalSwap(SendLogRequest* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "backup.SendLogRequest";
	+ }
	+ protected:
	+ explicit SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ private:
	+ static void ArenaDtor(void* object);
	+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ public:
	+
	+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
	+ private:
	+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
	+ return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kLogDataFieldNumber = 2,
	+ kAuthenticationDataFieldNumber = 1,
	+ };
	+ // bytes logData = 2;
	+ void clear_logdata();
	+ const std::string& logdata() const;
	+ void set_logdata(const std::string& value);
	+ void set_logdata(std::string&& value);
	+ void set_logdata(const char* value);
	+ void set_logdata(const void* value, size_t size);
	+ std::string* mutable_logdata();
	+ std::string* release_logdata();
	+ void set_allocated_logdata(std::string* logdata);
	+ private:
	+ const std::string& _internal_logdata() const;
	+ void _internal_set_logdata(const std::string& value);
	+ std::string* _internal_mutable_logdata();
	+ public:
	+
	+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
	+ bool has_authenticationdata() const;
	+ private:
	+ bool _internal_has_authenticationdata() const;
	+ public:
	+ void clear_authenticationdata();
	+ const ::backup::SimpleAuthenticationRequestData& authenticationdata() const;
	+ ::backup::SimpleAuthenticationRequestData* release_authenticationdata();
	+ ::backup::SimpleAuthenticationRequestData* mutable_authenticationdata();
	+ void set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata);
	+ private:
	+ const ::backup::SimpleAuthenticationRequestData& _internal_authenticationdata() const;
	+ ::backup::SimpleAuthenticationRequestData* _internal_mutable_authenticationdata();
	+ public:
	+ void unsafe_arena_set_allocated_authenticationdata(
	+ ::backup::SimpleAuthenticationRequestData* authenticationdata);
	+ ::backup::SimpleAuthenticationRequestData* unsafe_arena_release_authenticationdata();
	+
	+ // @@protoc_insertion_point(class_scope:backup.SendLogRequest)
	+ private:
	+ class _Internal;
	+
	+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	+ typedef void InternalArenaConstructable_;
	+ typedef void DestructorSkippable_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logdata_;
	+ ::backup::SimpleAuthenticationRequestData* authenticationdata_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_backup_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class RecoverBackupKeyRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.RecoverBackupKeyRequest) */ {
	+ public:
	+ inline RecoverBackupKeyRequest() : RecoverBackupKeyRequest(nullptr) {}
	+ virtual ~RecoverBackupKeyRequest();
	+ explicit constexpr RecoverBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ RecoverBackupKeyRequest(const RecoverBackupKeyRequest& from);
	+ RecoverBackupKeyRequest(RecoverBackupKeyRequest&& from) noexcept
	+ : RecoverBackupKeyRequest() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline RecoverBackupKeyRequest& operator=(const RecoverBackupKeyRequest& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline RecoverBackupKeyRequest& operator=(RecoverBackupKeyRequest&& from) noexcept {
	+ if (GetArena() == from.GetArena()) {
	+ if (this != &from) InternalSwap(&from);
	+ } else {
	+ CopyFrom(from);
	+ }
	+ return *this;
	+ }
	+
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
	+ return GetDescriptor();
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
	+ return GetMetadataStatic().descriptor;
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	+ return GetMetadataStatic().reflection;
	+ }
	+ static const RecoverBackupKeyRequest& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const RecoverBackupKeyRequest* internal_default_instance() {
	+ return reinterpret_cast<const RecoverBackupKeyRequest*>(
	+ &_RecoverBackupKeyRequest_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 7;
	+
	+ friend void swap(RecoverBackupKeyRequest& a, RecoverBackupKeyRequest& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(RecoverBackupKeyRequest* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(RecoverBackupKeyRequest* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline RecoverBackupKeyRequest* New() const final {
	+ return CreateMaybeMessage<RecoverBackupKeyRequest>(nullptr);
	+ }
	+
	+ RecoverBackupKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<RecoverBackupKeyRequest>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const RecoverBackupKeyRequest& from);
	+ void MergeFrom(const RecoverBackupKeyRequest& from);
	+ 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;
	+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
	+ int GetCachedSize() const final { return _cached_size_.Get(); }
	+
	+ private:
	+ inline void SharedCtor();
	+ inline void SharedDtor();
	+ void SetCachedSize(int size) const final;
	+ void InternalSwap(RecoverBackupKeyRequest* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "backup.RecoverBackupKeyRequest";
	+ }
	+ protected:
	+ explicit RecoverBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ private:
	+ static void ArenaDtor(void* object);
	+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ public:
	+
	+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
	+ private:
	+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
	+ return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kAuthenticationDataFieldNumber = 1,
	+ };
	+ // .backup.FullAuthenticationRequestData authenticationData = 1;
	+ bool has_authenticationdata() const;
	+ private:
	+ bool _internal_has_authenticationdata() const;
	+ public:
	+ void clear_authenticationdata();
	+ const ::backup::FullAuthenticationRequestData& authenticationdata() const;
	+ ::backup::FullAuthenticationRequestData* release_authenticationdata();
	+ ::backup::FullAuthenticationRequestData* mutable_authenticationdata();
	+ void set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata);
	+ private:
	+ const ::backup::FullAuthenticationRequestData& _internal_authenticationdata() const;
	+ ::backup::FullAuthenticationRequestData* _internal_mutable_authenticationdata();
	+ public:
	+ void unsafe_arena_set_allocated_authenticationdata(
	+ ::backup::FullAuthenticationRequestData* authenticationdata);
	+ ::backup::FullAuthenticationRequestData* unsafe_arena_release_authenticationdata();
	+
	+ // @@protoc_insertion_point(class_scope:backup.RecoverBackupKeyRequest)
	+ private:
	+ class _Internal;
	+
	+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	+ typedef void InternalArenaConstructable_;
	+ typedef void DestructorSkippable_;
	+ ::backup::FullAuthenticationRequestData* authenticationdata_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_backup_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class RecoverBackupKeyResponse PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.RecoverBackupKeyResponse) */ {
	+ public:
	+ inline RecoverBackupKeyResponse() : RecoverBackupKeyResponse(nullptr) {}
	+ virtual ~RecoverBackupKeyResponse();
	+ explicit constexpr RecoverBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ RecoverBackupKeyResponse(const RecoverBackupKeyResponse& from);
	+ RecoverBackupKeyResponse(RecoverBackupKeyResponse&& from) noexcept
	+ : RecoverBackupKeyResponse() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline RecoverBackupKeyResponse& operator=(const RecoverBackupKeyResponse& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline RecoverBackupKeyResponse& operator=(RecoverBackupKeyResponse&& from) noexcept {
	+ if (GetArena() == from.GetArena()) {
	+ if (this != &from) InternalSwap(&from);
	+ } else {
	+ CopyFrom(from);
	+ }
	+ return *this;
	+ }
	+
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
	+ return GetDescriptor();
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
	+ return GetMetadataStatic().descriptor;
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	+ return GetMetadataStatic().reflection;
	+ }
	+ static const RecoverBackupKeyResponse& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ enum DataCase {
	+ kAuthenticationResponseData = 1,
	+ kAuthenticationInformationData = 2,
	+ kBackupID = 3,
	+ DATA_NOT_SET = 0,
	+ };
	+
	+ static inline const RecoverBackupKeyResponse* internal_default_instance() {
	+ return reinterpret_cast<const RecoverBackupKeyResponse*>(
	+ &_RecoverBackupKeyResponse_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 8;
	+
	+ friend void swap(RecoverBackupKeyResponse& a, RecoverBackupKeyResponse& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(RecoverBackupKeyResponse* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(RecoverBackupKeyResponse* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline RecoverBackupKeyResponse* New() const final {
	+ return CreateMaybeMessage<RecoverBackupKeyResponse>(nullptr);
	+ }
	+
	+ RecoverBackupKeyResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<RecoverBackupKeyResponse>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const RecoverBackupKeyResponse& from);
	+ void MergeFrom(const RecoverBackupKeyResponse& from);
	+ 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;
	+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
	+ int GetCachedSize() const final { return _cached_size_.Get(); }
	+
	+ private:
	+ inline void SharedCtor();
	+ inline void SharedDtor();
	+ void SetCachedSize(int size) const final;
	+ void InternalSwap(RecoverBackupKeyResponse* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "backup.RecoverBackupKeyResponse";
	+ }
	+ protected:
	+ explicit RecoverBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ private:
	+ static void ArenaDtor(void* object);
	+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ public:
	+
	+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
	+ private:
	+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
	+ return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kAuthenticationResponseDataFieldNumber = 1,
	+ kAuthenticationInformationDataFieldNumber = 2,
	+ kBackupIDFieldNumber = 3,
	+ };
	+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
	+ bool has_authenticationresponsedata() const;
	+ private:
	+ bool _internal_has_authenticationresponsedata() const;
	+ public:
	+ void clear_authenticationresponsedata();
	+ const ::backup::FullAuthenticationResponseData& authenticationresponsedata() const;
	+ ::backup::FullAuthenticationResponseData* release_authenticationresponsedata();
	+ ::backup::FullAuthenticationResponseData* mutable_authenticationresponsedata();
	+ void set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata);
	+ private:
	+ const ::backup::FullAuthenticationResponseData& _internal_authenticationresponsedata() const;
	+ ::backup::FullAuthenticationResponseData* _internal_mutable_authenticationresponsedata();
	+ public:
	+ void unsafe_arena_set_allocated_authenticationresponsedata(
	+ ::backup::FullAuthenticationResponseData* authenticationresponsedata);
	+ ::backup::FullAuthenticationResponseData* unsafe_arena_release_authenticationresponsedata();
	+
	+ // .backup.AuthenticationInformationData authenticationInformationData = 2;
	+ bool has_authenticationinformationdata() const;
	+ private:
	+ bool _internal_has_authenticationinformationdata() const;
	+ public:
	+ void clear_authenticationinformationdata();
	+ const ::backup::AuthenticationInformationData& authenticationinformationdata() const;
	+ ::backup::AuthenticationInformationData* release_authenticationinformationdata();
	+ ::backup::AuthenticationInformationData* mutable_authenticationinformationdata();
	+ void set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata);
	+ private:
	+ const ::backup::AuthenticationInformationData& _internal_authenticationinformationdata() const;
	+ ::backup::AuthenticationInformationData* _internal_mutable_authenticationinformationdata();
	+ public:
	+ void unsafe_arena_set_allocated_authenticationinformationdata(
	+ ::backup::AuthenticationInformationData* authenticationinformationdata);
	+ ::backup::AuthenticationInformationData* unsafe_arena_release_authenticationinformationdata();
	+
	+ // string backupID = 3;
	+ bool has_backupid() const;
	+ private:
	+ bool _internal_has_backupid() const;
	+ public:
	+ void clear_backupid();
	+ const std::string& backupid() const;
	+ void set_backupid(const std::string& value);
	+ void set_backupid(std::string&& value);
	+ void set_backupid(const char* value);
	+ void set_backupid(const char* value, size_t size);
	+ std::string* mutable_backupid();
	+ std::string* release_backupid();
	+ void set_allocated_backupid(std::string* backupid);
	+ private:
	+ const std::string& _internal_backupid() const;
	+ void _internal_set_backupid(const std::string& value);
	+ std::string* _internal_mutable_backupid();
	+ public:
	+
	+ void clear_data();
	+ DataCase data_case() const;
	+ // @@protoc_insertion_point(class_scope:backup.RecoverBackupKeyResponse)
	+ private:
	+ class _Internal;
	+ void set_has_authenticationresponsedata();
	+ void set_has_authenticationinformationdata();
	+ void set_has_backupid();
	+
	+ inline bool has_data() const;
	+ inline void clear_has_data();
	+
	+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	+ typedef void InternalArenaConstructable_;
	+ typedef void DestructorSkippable_;
	+ union DataUnion {
	+ constexpr DataUnion() : _constinit_{} {}
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
	+ ::backup::FullAuthenticationResponseData* authenticationresponsedata_;
	+ ::backup::AuthenticationInformationData* authenticationinformationdata_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_;
	+ } data_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	+ friend struct ::TableStruct_backup_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class PullBackupRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupRequest) */ {
	+ public:
	+ inline PullBackupRequest() : PullBackupRequest(nullptr) {}
	+ virtual ~PullBackupRequest();
	+ explicit constexpr PullBackupRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ PullBackupRequest(const PullBackupRequest& from);
	+ PullBackupRequest(PullBackupRequest&& from) noexcept
	+ : PullBackupRequest() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline PullBackupRequest& operator=(const PullBackupRequest& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline PullBackupRequest& operator=(PullBackupRequest&& from) noexcept {
	+ if (GetArena() == from.GetArena()) {
	+ if (this != &from) InternalSwap(&from);
	+ } else {
	+ CopyFrom(from);
	+ }
	+ return *this;
	+ }
	+
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
	+ return GetDescriptor();
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
	+ return GetMetadataStatic().descriptor;
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	+ return GetMetadataStatic().reflection;
	+ }
	+ static const PullBackupRequest& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const PullBackupRequest* internal_default_instance() {
	+ return reinterpret_cast<const PullBackupRequest*>(
	+ &_PullBackupRequest_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 9;
	+
	+ friend void swap(PullBackupRequest& a, PullBackupRequest& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(PullBackupRequest* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(PullBackupRequest* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline PullBackupRequest* New() const final {
	+ return CreateMaybeMessage<PullBackupRequest>(nullptr);
	+ }
	+
	+ PullBackupRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<PullBackupRequest>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const PullBackupRequest& from);
	+ void MergeFrom(const PullBackupRequest& from);
	+ 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;
	+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
	+ int GetCachedSize() const final { return _cached_size_.Get(); }
	+
	+ private:
	+ inline void SharedCtor();
	+ inline void SharedDtor();
	+ void SetCachedSize(int size) const final;
	+ void InternalSwap(PullBackupRequest* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "backup.PullBackupRequest";
	+ }
	+ protected:
	+ explicit PullBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ private:
	+ static void ArenaDtor(void* object);
	+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ public:
	+
	+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
	+ private:
	+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
	+ return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kAuthenticationDataFieldNumber = 1,
	+ };
	+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
	+ bool has_authenticationdata() const;
	+ private:
	+ bool _internal_has_authenticationdata() const;
	+ public:
	+ void clear_authenticationdata();
	+ const ::backup::SimpleAuthenticationRequestData& authenticationdata() const;
	+ ::backup::SimpleAuthenticationRequestData* release_authenticationdata();
	+ ::backup::SimpleAuthenticationRequestData* mutable_authenticationdata();
	+ void set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata);
	+ private:
	+ const ::backup::SimpleAuthenticationRequestData& _internal_authenticationdata() const;
	+ ::backup::SimpleAuthenticationRequestData* _internal_mutable_authenticationdata();
	+ public:
	+ void unsafe_arena_set_allocated_authenticationdata(
	+ ::backup::SimpleAuthenticationRequestData* authenticationdata);
	+ ::backup::SimpleAuthenticationRequestData* unsafe_arena_release_authenticationdata();
	+
	+ // @@protoc_insertion_point(class_scope:backup.PullBackupRequest)
	+ private:
	+ class _Internal;
	+
	+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	+ typedef void InternalArenaConstructable_;
	+ typedef void DestructorSkippable_;
	+ ::backup::SimpleAuthenticationRequestData* authenticationdata_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_backup_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class PullBackupResponse PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupResponse) */ {
	+ public:
	+ inline PullBackupResponse() : PullBackupResponse(nullptr) {}
	+ virtual ~PullBackupResponse();
	+ explicit constexpr PullBackupResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ PullBackupResponse(const PullBackupResponse& from);
	+ PullBackupResponse(PullBackupResponse&& from) noexcept
	+ : PullBackupResponse() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline PullBackupResponse& operator=(const PullBackupResponse& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline PullBackupResponse& operator=(PullBackupResponse&& from) noexcept {
	+ if (GetArena() == from.GetArena()) {
	+ if (this != &from) InternalSwap(&from);
	+ } else {
	+ CopyFrom(from);
	+ }
	+ return *this;
	+ }
	+
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
	+ return GetDescriptor();
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
	+ return GetMetadataStatic().descriptor;
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	+ return GetMetadataStatic().reflection;
	+ }
	+ static const PullBackupResponse& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ enum DataCase {
	+ kCompactionChunk = 1,
	+ kLogChunk = 2,
	+ DATA_NOT_SET = 0,
	+ };
	+
	+ static inline const PullBackupResponse* internal_default_instance() {
	+ return reinterpret_cast<const PullBackupResponse*>(
	+ &_PullBackupResponse_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 10;
	+
	+ friend void swap(PullBackupResponse& a, PullBackupResponse& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(PullBackupResponse* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(PullBackupResponse* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline PullBackupResponse* New() const final {
	+ return CreateMaybeMessage<PullBackupResponse>(nullptr);
	+ }
	+
	+ PullBackupResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<PullBackupResponse>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const PullBackupResponse& from);
	+ void MergeFrom(const PullBackupResponse& from);
	+ 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;
	+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
	+ int GetCachedSize() const final { return _cached_size_.Get(); }
	+
	+ private:
	+ inline void SharedCtor();
	+ inline void SharedDtor();
	+ void SetCachedSize(int size) const final;
	+ void InternalSwap(PullBackupResponse* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "backup.PullBackupResponse";
	+ }
	+ protected:
	+ explicit PullBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ private:
	+ static void ArenaDtor(void* object);
	+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ public:
	+
	+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
	+ private:
	+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
	+ return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kCompactionChunkFieldNumber = 1,
	+ kLogChunkFieldNumber = 2,
	+ };
	+ // bytes compactionChunk = 1;
	+ bool has_compactionchunk() const;
	+ private:
	+ bool _internal_has_compactionchunk() const;
	+ public:
	+ void clear_compactionchunk();
	+ const std::string& compactionchunk() const;
	+ void set_compactionchunk(const std::string& value);
	+ void set_compactionchunk(std::string&& value);
	+ void set_compactionchunk(const char* value);
	+ void set_compactionchunk(const void* value, size_t size);
	+ std::string* mutable_compactionchunk();
	+ std::string* release_compactionchunk();
	+ void set_allocated_compactionchunk(std::string* compactionchunk);
	+ private:
	+ const std::string& _internal_compactionchunk() const;
	+ void _internal_set_compactionchunk(const std::string& value);
	+ std::string* _internal_mutable_compactionchunk();
	+ public:
	+
	+ // bytes logChunk = 2;
	+ bool has_logchunk() const;
	+ private:
	+ bool _internal_has_logchunk() const;
	+ public:
	+ void clear_logchunk();
	+ const std::string& logchunk() const;
	+ void set_logchunk(const std::string& value);
	+ void set_logchunk(std::string&& value);
	+ void set_logchunk(const char* value);
	+ void set_logchunk(const void* value, size_t size);
	+ std::string* mutable_logchunk();
	+ std::string* release_logchunk();
	+ void set_allocated_logchunk(std::string* logchunk);
	+ private:
	+ const std::string& _internal_logchunk() const;
	+ void _internal_set_logchunk(const std::string& value);
	+ std::string* _internal_mutable_logchunk();
	+ public:
	+
	+ void clear_data();
	+ DataCase data_case() const;
	+ // @@protoc_insertion_point(class_scope:backup.PullBackupResponse)
	+ private:
	+ class _Internal;
	+ void set_has_compactionchunk();
	+ void set_has_logchunk();
	+
	+ inline bool has_data() const;
	+ inline void clear_has_data();
	+
	+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	+ typedef void InternalArenaConstructable_;
	+ typedef void DestructorSkippable_;
	+ union DataUnion {
	+ constexpr DataUnion() : _constinit_{} {}
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logchunk_;
	+ } data_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	+ friend struct ::TableStruct_backup_2eproto;
	+};
	+// ===================================================================
	+
	+
	+// ===================================================================
	+
	+#ifdef __GNUC__
	+ #pragma GCC diagnostic push
	+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
	+#endif // __GNUC__
	+// FullAuthenticationRequestData
	+
	+// bytes pakeRegistrationRequest = 1;
	+inline bool FullAuthenticationRequestData::_internal_has_pakeregistrationrequest() const {
	+ return requestBytes_case() == kPakeRegistrationRequest;
	+}
	+inline bool FullAuthenticationRequestData::has_pakeregistrationrequest() const {
	+ return _internal_has_pakeregistrationrequest();
	+}
	+inline void FullAuthenticationRequestData::set_has_pakeregistrationrequest() {
	+ _oneof_case_[0] = kPakeRegistrationRequest;
	+}
	+inline void FullAuthenticationRequestData::clear_pakeregistrationrequest() {
	+ if (_internal_has_pakeregistrationrequest()) {
	+ requestBytes_.pakeregistrationrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_requestBytes();
	+ }
	+}
	+inline const std::string& FullAuthenticationRequestData::pakeregistrationrequest() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
	+ return _internal_pakeregistrationrequest();
	+}
	+inline void FullAuthenticationRequestData::set_pakeregistrationrequest(const std::string& value) {
	+ _internal_set_pakeregistrationrequest(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
	+}
	+inline std::string* FullAuthenticationRequestData::mutable_pakeregistrationrequest() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
	+ return _internal_mutable_pakeregistrationrequest();
	+}
	+inline const std::string& FullAuthenticationRequestData::_internal_pakeregistrationrequest() const {
	+ if (_internal_has_pakeregistrationrequest()) {
	+ return requestBytes_.pakeregistrationrequest_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void FullAuthenticationRequestData::_internal_set_pakeregistrationrequest(const std::string& value) {
	+ if (!_internal_has_pakeregistrationrequest()) {
	+ clear_requestBytes();
	+ set_has_pakeregistrationrequest();
	+ requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationRequestData::set_pakeregistrationrequest(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
	+ if (!_internal_has_pakeregistrationrequest()) {
	+ clear_requestBytes();
	+ set_has_pakeregistrationrequest();
	+ requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakeregistrationrequest_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
	+}
	+inline void FullAuthenticationRequestData::set_pakeregistrationrequest(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakeregistrationrequest()) {
	+ clear_requestBytes();
	+ set_has_pakeregistrationrequest();
	+ requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
	+}
	+inline void FullAuthenticationRequestData::set_pakeregistrationrequest(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakeregistrationrequest()) {
	+ clear_requestBytes();
	+ set_has_pakeregistrationrequest();
	+ requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakeregistrationrequest_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
	+}
	+inline std::string* FullAuthenticationRequestData::_internal_mutable_pakeregistrationrequest() {
	+ if (!_internal_has_pakeregistrationrequest()) {
	+ clear_requestBytes();
	+ set_has_pakeregistrationrequest();
	+ requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return requestBytes_.pakeregistrationrequest_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationRequestData::release_pakeregistrationrequest() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
	+ if (_internal_has_pakeregistrationrequest()) {
	+ clear_has_requestBytes();
	+ return requestBytes_.pakeregistrationrequest_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void FullAuthenticationRequestData::set_allocated_pakeregistrationrequest(std::string* pakeregistrationrequest) {
	+ if (has_requestBytes()) {
	+ clear_requestBytes();
	+ }
	+ if (pakeregistrationrequest != nullptr) {
	+ set_has_pakeregistrationrequest();
	+ requestBytes_.pakeregistrationrequest_.UnsafeSetDefault(pakeregistrationrequest);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakeregistrationrequest);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeRegistrationRequest)
	+}
	+
	+// bytes pakeRegistrationUpload = 2;
	+inline bool FullAuthenticationRequestData::_internal_has_pakeregistrationupload() const {
	+ return requestBytes_case() == kPakeRegistrationUpload;
	+}
	+inline bool FullAuthenticationRequestData::has_pakeregistrationupload() const {
	+ return _internal_has_pakeregistrationupload();
	+}
	+inline void FullAuthenticationRequestData::set_has_pakeregistrationupload() {
	+ _oneof_case_[0] = kPakeRegistrationUpload;
	+}
	+inline void FullAuthenticationRequestData::clear_pakeregistrationupload() {
	+ if (_internal_has_pakeregistrationupload()) {
	+ requestBytes_.pakeregistrationupload_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_requestBytes();
	+ }
	+}
	+inline const std::string& FullAuthenticationRequestData::pakeregistrationupload() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
	+ return _internal_pakeregistrationupload();
	+}
	+inline void FullAuthenticationRequestData::set_pakeregistrationupload(const std::string& value) {
	+ _internal_set_pakeregistrationupload(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
	+}
	+inline std::string* FullAuthenticationRequestData::mutable_pakeregistrationupload() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
	+ return _internal_mutable_pakeregistrationupload();
	+}
	+inline const std::string& FullAuthenticationRequestData::_internal_pakeregistrationupload() const {
	+ if (_internal_has_pakeregistrationupload()) {
	+ return requestBytes_.pakeregistrationupload_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void FullAuthenticationRequestData::_internal_set_pakeregistrationupload(const std::string& value) {
	+ if (!_internal_has_pakeregistrationupload()) {
	+ clear_requestBytes();
	+ set_has_pakeregistrationupload();
	+ requestBytes_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationRequestData::set_pakeregistrationupload(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
	+ if (!_internal_has_pakeregistrationupload()) {
	+ clear_requestBytes();
	+ set_has_pakeregistrationupload();
	+ requestBytes_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakeregistrationupload_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
	+}
	+inline void FullAuthenticationRequestData::set_pakeregistrationupload(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakeregistrationupload()) {
	+ clear_requestBytes();
	+ set_has_pakeregistrationupload();
	+ requestBytes_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
	+}
	+inline void FullAuthenticationRequestData::set_pakeregistrationupload(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakeregistrationupload()) {
	+ clear_requestBytes();
	+ set_has_pakeregistrationupload();
	+ requestBytes_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakeregistrationupload_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
	+}
	+inline std::string* FullAuthenticationRequestData::_internal_mutable_pakeregistrationupload() {
	+ if (!_internal_has_pakeregistrationupload()) {
	+ clear_requestBytes();
	+ set_has_pakeregistrationupload();
	+ requestBytes_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return requestBytes_.pakeregistrationupload_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationRequestData::release_pakeregistrationupload() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
	+ if (_internal_has_pakeregistrationupload()) {
	+ clear_has_requestBytes();
	+ return requestBytes_.pakeregistrationupload_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void FullAuthenticationRequestData::set_allocated_pakeregistrationupload(std::string* pakeregistrationupload) {
	+ if (has_requestBytes()) {
	+ clear_requestBytes();
	+ }
	+ if (pakeregistrationupload != nullptr) {
	+ set_has_pakeregistrationupload();
	+ requestBytes_.pakeregistrationupload_.UnsafeSetDefault(pakeregistrationupload);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakeregistrationupload);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeRegistrationUpload)
	+}
	+
	+// bytes pakeCredentialRequest = 3;
	+inline bool FullAuthenticationRequestData::_internal_has_pakecredentialrequest() const {
	+ return requestBytes_case() == kPakeCredentialRequest;
	+}
	+inline bool FullAuthenticationRequestData::has_pakecredentialrequest() const {
	+ return _internal_has_pakecredentialrequest();
	+}
	+inline void FullAuthenticationRequestData::set_has_pakecredentialrequest() {
	+ _oneof_case_[0] = kPakeCredentialRequest;
	+}
	+inline void FullAuthenticationRequestData::clear_pakecredentialrequest() {
	+ if (_internal_has_pakecredentialrequest()) {
	+ requestBytes_.pakecredentialrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_requestBytes();
	+ }
	+}
	+inline const std::string& FullAuthenticationRequestData::pakecredentialrequest() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeCredentialRequest)
	+ return _internal_pakecredentialrequest();
	+}
	+inline void FullAuthenticationRequestData::set_pakecredentialrequest(const std::string& value) {
	+ _internal_set_pakecredentialrequest(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeCredentialRequest)
	+}
	+inline std::string* FullAuthenticationRequestData::mutable_pakecredentialrequest() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeCredentialRequest)
	+ return _internal_mutable_pakecredentialrequest();
	+}
	+inline const std::string& FullAuthenticationRequestData::_internal_pakecredentialrequest() const {
	+ if (_internal_has_pakecredentialrequest()) {
	+ return requestBytes_.pakecredentialrequest_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void FullAuthenticationRequestData::_internal_set_pakecredentialrequest(const std::string& value) {
	+ if (!_internal_has_pakecredentialrequest()) {
	+ clear_requestBytes();
	+ set_has_pakecredentialrequest();
	+ requestBytes_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationRequestData::set_pakecredentialrequest(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeCredentialRequest)
	+ if (!_internal_has_pakecredentialrequest()) {
	+ clear_requestBytes();
	+ set_has_pakecredentialrequest();
	+ requestBytes_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakecredentialrequest_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.pakeCredentialRequest)
	+}
	+inline void FullAuthenticationRequestData::set_pakecredentialrequest(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakecredentialrequest()) {
	+ clear_requestBytes();
	+ set_has_pakecredentialrequest();
	+ requestBytes_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.pakeCredentialRequest)
	+}
	+inline void FullAuthenticationRequestData::set_pakecredentialrequest(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakecredentialrequest()) {
	+ clear_requestBytes();
	+ set_has_pakecredentialrequest();
	+ requestBytes_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakecredentialrequest_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.pakeCredentialRequest)
	+}
	+inline std::string* FullAuthenticationRequestData::_internal_mutable_pakecredentialrequest() {
	+ if (!_internal_has_pakecredentialrequest()) {
	+ clear_requestBytes();
	+ set_has_pakecredentialrequest();
	+ requestBytes_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return requestBytes_.pakecredentialrequest_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationRequestData::release_pakecredentialrequest() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeCredentialRequest)
	+ if (_internal_has_pakecredentialrequest()) {
	+ clear_has_requestBytes();
	+ return requestBytes_.pakecredentialrequest_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void FullAuthenticationRequestData::set_allocated_pakecredentialrequest(std::string* pakecredentialrequest) {
	+ if (has_requestBytes()) {
	+ clear_requestBytes();
	+ }
	+ if (pakecredentialrequest != nullptr) {
	+ set_has_pakecredentialrequest();
	+ requestBytes_.pakecredentialrequest_.UnsafeSetDefault(pakecredentialrequest);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakecredentialrequest);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeCredentialRequest)
	+}
	+
	+// bytes pakeCredentialFinalization = 4;
	+inline bool FullAuthenticationRequestData::_internal_has_pakecredentialfinalization() const {
	+ return requestBytes_case() == kPakeCredentialFinalization;
	+}
	+inline bool FullAuthenticationRequestData::has_pakecredentialfinalization() const {
	+ return _internal_has_pakecredentialfinalization();
	+}
	+inline void FullAuthenticationRequestData::set_has_pakecredentialfinalization() {
	+ _oneof_case_[0] = kPakeCredentialFinalization;
	+}
	+inline void FullAuthenticationRequestData::clear_pakecredentialfinalization() {
	+ if (_internal_has_pakecredentialfinalization()) {
	+ requestBytes_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_requestBytes();
	+ }
	+}
	+inline const std::string& FullAuthenticationRequestData::pakecredentialfinalization() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
	+ return _internal_pakecredentialfinalization();
	+}
	+inline void FullAuthenticationRequestData::set_pakecredentialfinalization(const std::string& value) {
	+ _internal_set_pakecredentialfinalization(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
	+}
	+inline std::string* FullAuthenticationRequestData::mutable_pakecredentialfinalization() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
	+ return _internal_mutable_pakecredentialfinalization();
	+}
	+inline const std::string& FullAuthenticationRequestData::_internal_pakecredentialfinalization() const {
	+ if (_internal_has_pakecredentialfinalization()) {
	+ return requestBytes_.pakecredentialfinalization_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void FullAuthenticationRequestData::_internal_set_pakecredentialfinalization(const std::string& value) {
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_requestBytes();
	+ set_has_pakecredentialfinalization();
	+ requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakecredentialfinalization_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationRequestData::set_pakecredentialfinalization(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_requestBytes();
	+ set_has_pakecredentialfinalization();
	+ requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakecredentialfinalization_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
	+}
	+inline void FullAuthenticationRequestData::set_pakecredentialfinalization(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_requestBytes();
	+ set_has_pakecredentialfinalization();
	+ requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakecredentialfinalization_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
	+}
	+inline void FullAuthenticationRequestData::set_pakecredentialfinalization(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_requestBytes();
	+ set_has_pakecredentialfinalization();
	+ requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakecredentialfinalization_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
	+}
	+inline std::string* FullAuthenticationRequestData::_internal_mutable_pakecredentialfinalization() {
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_requestBytes();
	+ set_has_pakecredentialfinalization();
	+ requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return requestBytes_.pakecredentialfinalization_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationRequestData::release_pakecredentialfinalization() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
	+ if (_internal_has_pakecredentialfinalization()) {
	+ clear_has_requestBytes();
	+ return requestBytes_.pakecredentialfinalization_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void FullAuthenticationRequestData::set_allocated_pakecredentialfinalization(std::string* pakecredentialfinalization) {
	+ if (has_requestBytes()) {
	+ clear_requestBytes();
	+ }
	+ if (pakecredentialfinalization != nullptr) {
	+ set_has_pakecredentialfinalization();
	+ requestBytes_.pakecredentialfinalization_.UnsafeSetDefault(pakecredentialfinalization);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakecredentialfinalization);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeCredentialFinalization)
	+}
	+
	+// bytes pakeChallengeResponse = 5;
	+inline bool FullAuthenticationRequestData::_internal_has_pakechallengeresponse() const {
	+ return requestBytes_case() == kPakeChallengeResponse;
	+}
	+inline bool FullAuthenticationRequestData::has_pakechallengeresponse() const {
	+ return _internal_has_pakechallengeresponse();
	+}
	+inline void FullAuthenticationRequestData::set_has_pakechallengeresponse() {
	+ _oneof_case_[0] = kPakeChallengeResponse;
	+}
	+inline void FullAuthenticationRequestData::clear_pakechallengeresponse() {
	+ if (_internal_has_pakechallengeresponse()) {
	+ requestBytes_.pakechallengeresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_requestBytes();
	+ }
	+}
	+inline const std::string& FullAuthenticationRequestData::pakechallengeresponse() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeChallengeResponse)
	+ return _internal_pakechallengeresponse();
	+}
	+inline void FullAuthenticationRequestData::set_pakechallengeresponse(const std::string& value) {
	+ _internal_set_pakechallengeresponse(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeChallengeResponse)
	+}
	+inline std::string* FullAuthenticationRequestData::mutable_pakechallengeresponse() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeChallengeResponse)
	+ return _internal_mutable_pakechallengeresponse();
	+}
	+inline const std::string& FullAuthenticationRequestData::_internal_pakechallengeresponse() const {
	+ if (_internal_has_pakechallengeresponse()) {
	+ return requestBytes_.pakechallengeresponse_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void FullAuthenticationRequestData::_internal_set_pakechallengeresponse(const std::string& value) {
	+ if (!_internal_has_pakechallengeresponse()) {
	+ clear_requestBytes();
	+ set_has_pakechallengeresponse();
	+ requestBytes_.pakechallengeresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakechallengeresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationRequestData::set_pakechallengeresponse(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.pakeChallengeResponse)
	+ if (!_internal_has_pakechallengeresponse()) {
	+ clear_requestBytes();
	+ set_has_pakechallengeresponse();
	+ requestBytes_.pakechallengeresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakechallengeresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.pakeChallengeResponse)
	+}
	+inline void FullAuthenticationRequestData::set_pakechallengeresponse(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakechallengeresponse()) {
	+ clear_requestBytes();
	+ set_has_pakechallengeresponse();
	+ requestBytes_.pakechallengeresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakechallengeresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.pakeChallengeResponse)
	+}
	+inline void FullAuthenticationRequestData::set_pakechallengeresponse(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakechallengeresponse()) {
	+ clear_requestBytes();
	+ set_has_pakechallengeresponse();
	+ requestBytes_.pakechallengeresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.pakechallengeresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.pakeChallengeResponse)
	+}
	+inline std::string* FullAuthenticationRequestData::_internal_mutable_pakechallengeresponse() {
	+ if (!_internal_has_pakechallengeresponse()) {
	+ clear_requestBytes();
	+ set_has_pakechallengeresponse();
	+ requestBytes_.pakechallengeresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return requestBytes_.pakechallengeresponse_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationRequestData::release_pakechallengeresponse() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeChallengeResponse)
	+ if (_internal_has_pakechallengeresponse()) {
	+ clear_has_requestBytes();
	+ return requestBytes_.pakechallengeresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void FullAuthenticationRequestData::set_allocated_pakechallengeresponse(std::string* pakechallengeresponse) {
	+ if (has_requestBytes()) {
	+ clear_requestBytes();
	+ }
	+ if (pakechallengeresponse != nullptr) {
	+ set_has_pakechallengeresponse();
	+ requestBytes_.pakechallengeresponse_.UnsafeSetDefault(pakechallengeresponse);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakechallengeresponse);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeChallengeResponse)
	+}
	+
	+// bytes walletAuthenticationRequest = 6;
	+inline bool FullAuthenticationRequestData::_internal_has_walletauthenticationrequest() const {
	+ return requestBytes_case() == kWalletAuthenticationRequest;
	+}
	+inline bool FullAuthenticationRequestData::has_walletauthenticationrequest() const {
	+ return _internal_has_walletauthenticationrequest();
	+}
	+inline void FullAuthenticationRequestData::set_has_walletauthenticationrequest() {
	+ _oneof_case_[0] = kWalletAuthenticationRequest;
	+}
	+inline void FullAuthenticationRequestData::clear_walletauthenticationrequest() {
	+ if (_internal_has_walletauthenticationrequest()) {
	+ requestBytes_.walletauthenticationrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_requestBytes();
	+ }
	+}
	+inline const std::string& FullAuthenticationRequestData::walletauthenticationrequest() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
	+ return _internal_walletauthenticationrequest();
	+}
	+inline void FullAuthenticationRequestData::set_walletauthenticationrequest(const std::string& value) {
	+ _internal_set_walletauthenticationrequest(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
	+}
	+inline std::string* FullAuthenticationRequestData::mutable_walletauthenticationrequest() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
	+ return _internal_mutable_walletauthenticationrequest();
	+}
	+inline const std::string& FullAuthenticationRequestData::_internal_walletauthenticationrequest() const {
	+ if (_internal_has_walletauthenticationrequest()) {
	+ return requestBytes_.walletauthenticationrequest_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void FullAuthenticationRequestData::_internal_set_walletauthenticationrequest(const std::string& value) {
	+ if (!_internal_has_walletauthenticationrequest()) {
	+ clear_requestBytes();
	+ set_has_walletauthenticationrequest();
	+ requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.walletauthenticationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationRequestData::set_walletauthenticationrequest(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
	+ if (!_internal_has_walletauthenticationrequest()) {
	+ clear_requestBytes();
	+ set_has_walletauthenticationrequest();
	+ requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.walletauthenticationrequest_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
	+}
	+inline void FullAuthenticationRequestData::set_walletauthenticationrequest(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_walletauthenticationrequest()) {
	+ clear_requestBytes();
	+ set_has_walletauthenticationrequest();
	+ requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.walletauthenticationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
	+}
	+inline void FullAuthenticationRequestData::set_walletauthenticationrequest(const void* value,
	+ size_t size) {
	+ if (!_internal_has_walletauthenticationrequest()) {
	+ clear_requestBytes();
	+ set_has_walletauthenticationrequest();
	+ requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ requestBytes_.walletauthenticationrequest_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
	+}
	+inline std::string* FullAuthenticationRequestData::_internal_mutable_walletauthenticationrequest() {
	+ if (!_internal_has_walletauthenticationrequest()) {
	+ clear_requestBytes();
	+ set_has_walletauthenticationrequest();
	+ requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return requestBytes_.walletauthenticationrequest_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationRequestData::release_walletauthenticationrequest() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
	+ if (_internal_has_walletauthenticationrequest()) {
	+ clear_has_requestBytes();
	+ return requestBytes_.walletauthenticationrequest_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void FullAuthenticationRequestData::set_allocated_walletauthenticationrequest(std::string* walletauthenticationrequest) {
	+ if (has_requestBytes()) {
	+ clear_requestBytes();
	+ }
	+ if (walletauthenticationrequest != nullptr) {
	+ set_has_walletauthenticationrequest();
	+ requestBytes_.walletauthenticationrequest_.UnsafeSetDefault(walletauthenticationrequest);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(walletauthenticationrequest);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.walletAuthenticationRequest)
	+}
	+
	+// string userID = 7;
	+inline void FullAuthenticationRequestData::clear_userid() {
	+ userid_.ClearToEmpty();
	+}
	+inline const std::string& FullAuthenticationRequestData::userid() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.userID)
	+ return _internal_userid();
	+}
	+inline void FullAuthenticationRequestData::set_userid(const std::string& value) {
	+ _internal_set_userid(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.userID)
	+}
	+inline std::string* FullAuthenticationRequestData::mutable_userid() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.userID)
	+ return _internal_mutable_userid();
	+}
	+inline const std::string& FullAuthenticationRequestData::_internal_userid() const {
	+ return userid_.Get();
	+}
	+inline void FullAuthenticationRequestData::_internal_set_userid(const std::string& value) {
	+
	+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationRequestData::set_userid(std::string&& value) {
	+
	+ userid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.userID)
	+}
	+inline void FullAuthenticationRequestData::set_userid(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.userID)
	+}
	+inline void FullAuthenticationRequestData::set_userid(const char* value,
	+ size_t size) {
	+
	+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.userID)
	+}
	+inline std::string* FullAuthenticationRequestData::_internal_mutable_userid() {
	+
	+ return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationRequestData::release_userid() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.userID)
	+ return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void FullAuthenticationRequestData::set_allocated_userid(std::string* userid) {
	+ if (userid != nullptr) {
	+
	+ } else {
	+
	+ }
	+ userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.userID)
	+}
	+
	+inline bool FullAuthenticationRequestData::has_requestBytes() const {
	+ return requestBytes_case() != REQUESTBYTES_NOT_SET;
	+}
	+inline void FullAuthenticationRequestData::clear_has_requestBytes() {
	+ _oneof_case_[0] = REQUESTBYTES_NOT_SET;
	+}
	+inline FullAuthenticationRequestData::RequestBytesCase FullAuthenticationRequestData::requestBytes_case() const {
	+ return FullAuthenticationRequestData::RequestBytesCase(_oneof_case_[0]);
	+}
	+// -------------------------------------------------------------------
	+
	+// FullAuthenticationResponseData
	+
	+// bytes pakeRegistrationResponse = 1;
	+inline bool FullAuthenticationResponseData::_internal_has_pakeregistrationresponse() const {
	+ return responseData_case() == kPakeRegistrationResponse;
	+}
	+inline bool FullAuthenticationResponseData::has_pakeregistrationresponse() const {
	+ return _internal_has_pakeregistrationresponse();
	+}
	+inline void FullAuthenticationResponseData::set_has_pakeregistrationresponse() {
	+ _oneof_case_[0] = kPakeRegistrationResponse;
	+}
	+inline void FullAuthenticationResponseData::clear_pakeregistrationresponse() {
	+ if (_internal_has_pakeregistrationresponse()) {
	+ responseData_.pakeregistrationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_responseData();
	+ }
	+}
	+inline const std::string& FullAuthenticationResponseData::pakeregistrationresponse() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
	+ return _internal_pakeregistrationresponse();
	+}
	+inline void FullAuthenticationResponseData::set_pakeregistrationresponse(const std::string& value) {
	+ _internal_set_pakeregistrationresponse(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
	+}
	+inline std::string* FullAuthenticationResponseData::mutable_pakeregistrationresponse() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
	+ return _internal_mutable_pakeregistrationresponse();
	+}
	+inline const std::string& FullAuthenticationResponseData::_internal_pakeregistrationresponse() const {
	+ if (_internal_has_pakeregistrationresponse()) {
	+ return responseData_.pakeregistrationresponse_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void FullAuthenticationResponseData::_internal_set_pakeregistrationresponse(const std::string& value) {
	+ if (!_internal_has_pakeregistrationresponse()) {
	+ clear_responseData();
	+ set_has_pakeregistrationresponse();
	+ responseData_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakeregistrationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationResponseData::set_pakeregistrationresponse(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
	+ if (!_internal_has_pakeregistrationresponse()) {
	+ clear_responseData();
	+ set_has_pakeregistrationresponse();
	+ responseData_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakeregistrationresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
	+}
	+inline void FullAuthenticationResponseData::set_pakeregistrationresponse(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakeregistrationresponse()) {
	+ clear_responseData();
	+ set_has_pakeregistrationresponse();
	+ responseData_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakeregistrationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
	+}
	+inline void FullAuthenticationResponseData::set_pakeregistrationresponse(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakeregistrationresponse()) {
	+ clear_responseData();
	+ set_has_pakeregistrationresponse();
	+ responseData_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakeregistrationresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
	+}
	+inline std::string* FullAuthenticationResponseData::_internal_mutable_pakeregistrationresponse() {
	+ if (!_internal_has_pakeregistrationresponse()) {
	+ clear_responseData();
	+ set_has_pakeregistrationresponse();
	+ responseData_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return responseData_.pakeregistrationresponse_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationResponseData::release_pakeregistrationresponse() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
	+ if (_internal_has_pakeregistrationresponse()) {
	+ clear_has_responseData();
	+ return responseData_.pakeregistrationresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void FullAuthenticationResponseData::set_allocated_pakeregistrationresponse(std::string* pakeregistrationresponse) {
	+ if (has_responseData()) {
	+ clear_responseData();
	+ }
	+ if (pakeregistrationresponse != nullptr) {
	+ set_has_pakeregistrationresponse();
	+ responseData_.pakeregistrationresponse_.UnsafeSetDefault(pakeregistrationresponse);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakeregistrationresponse);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationResponseData.pakeRegistrationResponse)
	+}
	+
	+// bool pakeRegistrationSuccess = 2;
	+inline bool FullAuthenticationResponseData::_internal_has_pakeregistrationsuccess() const {
	+ return responseData_case() == kPakeRegistrationSuccess;
	+}
	+inline bool FullAuthenticationResponseData::has_pakeregistrationsuccess() const {
	+ return _internal_has_pakeregistrationsuccess();
	+}
	+inline void FullAuthenticationResponseData::set_has_pakeregistrationsuccess() {
	+ _oneof_case_[0] = kPakeRegistrationSuccess;
	+}
	+inline void FullAuthenticationResponseData::clear_pakeregistrationsuccess() {
	+ if (_internal_has_pakeregistrationsuccess()) {
	+ responseData_.pakeregistrationsuccess_ = false;
	+ clear_has_responseData();
	+ }
	+}
	+inline bool FullAuthenticationResponseData::_internal_pakeregistrationsuccess() const {
	+ if (_internal_has_pakeregistrationsuccess()) {
	+ return responseData_.pakeregistrationsuccess_;
	+ }
	+ return false;
	+}
	+inline void FullAuthenticationResponseData::_internal_set_pakeregistrationsuccess(bool value) {
	+ if (!_internal_has_pakeregistrationsuccess()) {
	+ clear_responseData();
	+ set_has_pakeregistrationsuccess();
	+ }
	+ responseData_.pakeregistrationsuccess_ = value;
	+}
	+inline bool FullAuthenticationResponseData::pakeregistrationsuccess() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.pakeRegistrationSuccess)
	+ return _internal_pakeregistrationsuccess();
	+}
	+inline void FullAuthenticationResponseData::set_pakeregistrationsuccess(bool value) {
	+ _internal_set_pakeregistrationsuccess(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeRegistrationSuccess)
	+}
	+
	+// bytes pakeCredentialResponse = 3;
	+inline bool FullAuthenticationResponseData::_internal_has_pakecredentialresponse() const {
	+ return responseData_case() == kPakeCredentialResponse;
	+}
	+inline bool FullAuthenticationResponseData::has_pakecredentialresponse() const {
	+ return _internal_has_pakecredentialresponse();
	+}
	+inline void FullAuthenticationResponseData::set_has_pakecredentialresponse() {
	+ _oneof_case_[0] = kPakeCredentialResponse;
	+}
	+inline void FullAuthenticationResponseData::clear_pakecredentialresponse() {
	+ if (_internal_has_pakecredentialresponse()) {
	+ responseData_.pakecredentialresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_responseData();
	+ }
	+}
	+inline const std::string& FullAuthenticationResponseData::pakecredentialresponse() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.pakeCredentialResponse)
	+ return _internal_pakecredentialresponse();
	+}
	+inline void FullAuthenticationResponseData::set_pakecredentialresponse(const std::string& value) {
	+ _internal_set_pakecredentialresponse(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeCredentialResponse)
	+}
	+inline std::string* FullAuthenticationResponseData::mutable_pakecredentialresponse() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationResponseData.pakeCredentialResponse)
	+ return _internal_mutable_pakecredentialresponse();
	+}
	+inline const std::string& FullAuthenticationResponseData::_internal_pakecredentialresponse() const {
	+ if (_internal_has_pakecredentialresponse()) {
	+ return responseData_.pakecredentialresponse_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void FullAuthenticationResponseData::_internal_set_pakecredentialresponse(const std::string& value) {
	+ if (!_internal_has_pakecredentialresponse()) {
	+ clear_responseData();
	+ set_has_pakecredentialresponse();
	+ responseData_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakecredentialresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationResponseData::set_pakecredentialresponse(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeCredentialResponse)
	+ if (!_internal_has_pakecredentialresponse()) {
	+ clear_responseData();
	+ set_has_pakecredentialresponse();
	+ responseData_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakecredentialresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationResponseData.pakeCredentialResponse)
	+}
	+inline void FullAuthenticationResponseData::set_pakecredentialresponse(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakecredentialresponse()) {
	+ clear_responseData();
	+ set_has_pakecredentialresponse();
	+ responseData_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakecredentialresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationResponseData.pakeCredentialResponse)
	+}
	+inline void FullAuthenticationResponseData::set_pakecredentialresponse(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakecredentialresponse()) {
	+ clear_responseData();
	+ set_has_pakecredentialresponse();
	+ responseData_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakecredentialresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationResponseData.pakeCredentialResponse)
	+}
	+inline std::string* FullAuthenticationResponseData::_internal_mutable_pakecredentialresponse() {
	+ if (!_internal_has_pakecredentialresponse()) {
	+ clear_responseData();
	+ set_has_pakecredentialresponse();
	+ responseData_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return responseData_.pakecredentialresponse_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationResponseData::release_pakecredentialresponse() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationResponseData.pakeCredentialResponse)
	+ if (_internal_has_pakecredentialresponse()) {
	+ clear_has_responseData();
	+ return responseData_.pakecredentialresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void FullAuthenticationResponseData::set_allocated_pakecredentialresponse(std::string* pakecredentialresponse) {
	+ if (has_responseData()) {
	+ clear_responseData();
	+ }
	+ if (pakecredentialresponse != nullptr) {
	+ set_has_pakecredentialresponse();
	+ responseData_.pakecredentialresponse_.UnsafeSetDefault(pakecredentialresponse);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakecredentialresponse);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationResponseData.pakeCredentialResponse)
	+}
	+
	+// bytes pakeChallengeMessage = 4;
	+inline bool FullAuthenticationResponseData::_internal_has_pakechallengemessage() const {
	+ return responseData_case() == kPakeChallengeMessage;
	+}
	+inline bool FullAuthenticationResponseData::has_pakechallengemessage() const {
	+ return _internal_has_pakechallengemessage();
	+}
	+inline void FullAuthenticationResponseData::set_has_pakechallengemessage() {
	+ _oneof_case_[0] = kPakeChallengeMessage;
	+}
	+inline void FullAuthenticationResponseData::clear_pakechallengemessage() {
	+ if (_internal_has_pakechallengemessage()) {
	+ responseData_.pakechallengemessage_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_responseData();
	+ }
	+}
	+inline const std::string& FullAuthenticationResponseData::pakechallengemessage() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.pakeChallengeMessage)
	+ return _internal_pakechallengemessage();
	+}
	+inline void FullAuthenticationResponseData::set_pakechallengemessage(const std::string& value) {
	+ _internal_set_pakechallengemessage(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeChallengeMessage)
	+}
	+inline std::string* FullAuthenticationResponseData::mutable_pakechallengemessage() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationResponseData.pakeChallengeMessage)
	+ return _internal_mutable_pakechallengemessage();
	+}
	+inline const std::string& FullAuthenticationResponseData::_internal_pakechallengemessage() const {
	+ if (_internal_has_pakechallengemessage()) {
	+ return responseData_.pakechallengemessage_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void FullAuthenticationResponseData::_internal_set_pakechallengemessage(const std::string& value) {
	+ if (!_internal_has_pakechallengemessage()) {
	+ clear_responseData();
	+ set_has_pakechallengemessage();
	+ responseData_.pakechallengemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakechallengemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationResponseData::set_pakechallengemessage(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.pakeChallengeMessage)
	+ if (!_internal_has_pakechallengemessage()) {
	+ clear_responseData();
	+ set_has_pakechallengemessage();
	+ responseData_.pakechallengemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakechallengemessage_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationResponseData.pakeChallengeMessage)
	+}
	+inline void FullAuthenticationResponseData::set_pakechallengemessage(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakechallengemessage()) {
	+ clear_responseData();
	+ set_has_pakechallengemessage();
	+ responseData_.pakechallengemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakechallengemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationResponseData.pakeChallengeMessage)
	+}
	+inline void FullAuthenticationResponseData::set_pakechallengemessage(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakechallengemessage()) {
	+ clear_responseData();
	+ set_has_pakechallengemessage();
	+ responseData_.pakechallengemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.pakechallengemessage_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationResponseData.pakeChallengeMessage)
	+}
	+inline std::string* FullAuthenticationResponseData::_internal_mutable_pakechallengemessage() {
	+ if (!_internal_has_pakechallengemessage()) {
	+ clear_responseData();
	+ set_has_pakechallengemessage();
	+ responseData_.pakechallengemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return responseData_.pakechallengemessage_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationResponseData::release_pakechallengemessage() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationResponseData.pakeChallengeMessage)
	+ if (_internal_has_pakechallengemessage()) {
	+ clear_has_responseData();
	+ return responseData_.pakechallengemessage_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void FullAuthenticationResponseData::set_allocated_pakechallengemessage(std::string* pakechallengemessage) {
	+ if (has_responseData()) {
	+ clear_responseData();
	+ }
	+ if (pakechallengemessage != nullptr) {
	+ set_has_pakechallengemessage();
	+ responseData_.pakechallengemessage_.UnsafeSetDefault(pakechallengemessage);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakechallengemessage);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationResponseData.pakeChallengeMessage)
	+}
	+
	+// bytes walletAuthenticationResponse = 5;
	+inline bool FullAuthenticationResponseData::_internal_has_walletauthenticationresponse() const {
	+ return responseData_case() == kWalletAuthenticationResponse;
	+}
	+inline bool FullAuthenticationResponseData::has_walletauthenticationresponse() const {
	+ return _internal_has_walletauthenticationresponse();
	+}
	+inline void FullAuthenticationResponseData::set_has_walletauthenticationresponse() {
	+ _oneof_case_[0] = kWalletAuthenticationResponse;
	+}
	+inline void FullAuthenticationResponseData::clear_walletauthenticationresponse() {
	+ if (_internal_has_walletauthenticationresponse()) {
	+ responseData_.walletauthenticationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_responseData();
	+ }
	+}
	+inline const std::string& FullAuthenticationResponseData::walletauthenticationresponse() const {
	+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
	+ return _internal_walletauthenticationresponse();
	+}
	+inline void FullAuthenticationResponseData::set_walletauthenticationresponse(const std::string& value) {
	+ _internal_set_walletauthenticationresponse(value);
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
	+}
	+inline std::string* FullAuthenticationResponseData::mutable_walletauthenticationresponse() {
	+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
	+ return _internal_mutable_walletauthenticationresponse();
	+}
	+inline const std::string& FullAuthenticationResponseData::_internal_walletauthenticationresponse() const {
	+ if (_internal_has_walletauthenticationresponse()) {
	+ return responseData_.walletauthenticationresponse_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void FullAuthenticationResponseData::_internal_set_walletauthenticationresponse(const std::string& value) {
	+ if (!_internal_has_walletauthenticationresponse()) {
	+ clear_responseData();
	+ set_has_walletauthenticationresponse();
	+ responseData_.walletauthenticationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.walletauthenticationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void FullAuthenticationResponseData::set_walletauthenticationresponse(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
	+ if (!_internal_has_walletauthenticationresponse()) {
	+ clear_responseData();
	+ set_has_walletauthenticationresponse();
	+ responseData_.walletauthenticationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.walletauthenticationresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
	+}
	+inline void FullAuthenticationResponseData::set_walletauthenticationresponse(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_walletauthenticationresponse()) {
	+ clear_responseData();
	+ set_has_walletauthenticationresponse();
	+ responseData_.walletauthenticationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.walletauthenticationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
	+}
	+inline void FullAuthenticationResponseData::set_walletauthenticationresponse(const void* value,
	+ size_t size) {
	+ if (!_internal_has_walletauthenticationresponse()) {
	+ clear_responseData();
	+ set_has_walletauthenticationresponse();
	+ responseData_.walletauthenticationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ responseData_.walletauthenticationresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
	+}
	+inline std::string* FullAuthenticationResponseData::_internal_mutable_walletauthenticationresponse() {
	+ if (!_internal_has_walletauthenticationresponse()) {
	+ clear_responseData();
	+ set_has_walletauthenticationresponse();
	+ responseData_.walletauthenticationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return responseData_.walletauthenticationresponse_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* FullAuthenticationResponseData::release_walletauthenticationresponse() {
	+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
	+ if (_internal_has_walletauthenticationresponse()) {
	+ clear_has_responseData();
	+ return responseData_.walletauthenticationresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void FullAuthenticationResponseData::set_allocated_walletauthenticationresponse(std::string* walletauthenticationresponse) {
	+ if (has_responseData()) {
	+ clear_responseData();
	+ }
	+ if (walletauthenticationresponse != nullptr) {
	+ set_has_walletauthenticationresponse();
	+ responseData_.walletauthenticationresponse_.UnsafeSetDefault(walletauthenticationresponse);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(walletauthenticationresponse);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationResponseData.walletAuthenticationResponse)
	+}
	+
	+inline bool FullAuthenticationResponseData::has_responseData() const {
	+ return responseData_case() != RESPONSEDATA_NOT_SET;
	+}
	+inline void FullAuthenticationResponseData::clear_has_responseData() {
	+ _oneof_case_[0] = RESPONSEDATA_NOT_SET;
	+}
	+inline FullAuthenticationResponseData::ResponseDataCase FullAuthenticationResponseData::responseData_case() const {
	+ return FullAuthenticationResponseData::ResponseDataCase(_oneof_case_[0]);
	+}
	+// -------------------------------------------------------------------
	+
	+// SimpleAuthenticationRequestData
	+
	+// string backupID = 1;
	+inline void SimpleAuthenticationRequestData::clear_backupid() {
	+ backupid_.ClearToEmpty();
	+}
	+inline const std::string& SimpleAuthenticationRequestData::backupid() const {
	+ // @@protoc_insertion_point(field_get:backup.SimpleAuthenticationRequestData.backupID)
	+ return _internal_backupid();
	+}
	+inline void SimpleAuthenticationRequestData::set_backupid(const std::string& value) {
	+ _internal_set_backupid(value);
	+ // @@protoc_insertion_point(field_set:backup.SimpleAuthenticationRequestData.backupID)
	+}
	+inline std::string* SimpleAuthenticationRequestData::mutable_backupid() {
	+ // @@protoc_insertion_point(field_mutable:backup.SimpleAuthenticationRequestData.backupID)
	+ return _internal_mutable_backupid();
	+}
	+inline const std::string& SimpleAuthenticationRequestData::_internal_backupid() const {
	+ return backupid_.Get();
	+}
	+inline void SimpleAuthenticationRequestData::_internal_set_backupid(const std::string& value) {
	+
	+ backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void SimpleAuthenticationRequestData::set_backupid(std::string&& value) {
	+
	+ backupid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.SimpleAuthenticationRequestData.backupID)
	+}
	+inline void SimpleAuthenticationRequestData::set_backupid(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.SimpleAuthenticationRequestData.backupID)
	}
	-inline void ResetKeyRequest::_internal_set_userid(const std::string& value) {
	+inline void SimpleAuthenticationRequestData::set_backupid(const char* value,
	+ size_t size) {
	+
	+ backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.SimpleAuthenticationRequestData.backupID)
	+}
	+inline std::string* SimpleAuthenticationRequestData::_internal_mutable_backupid() {
	+
	+ return backupid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* SimpleAuthenticationRequestData::release_backupid() {
	+ // @@protoc_insertion_point(field_release:backup.SimpleAuthenticationRequestData.backupID)
	+ return backupid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void SimpleAuthenticationRequestData::set_allocated_backupid(std::string* backupid) {
	+ if (backupid != nullptr) {
	+
	+ } else {
	+
	+ }
	+ backupid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), backupid,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:backup.SimpleAuthenticationRequestData.backupID)
	+}
	+
	+// string userID = 2;
	+inline void SimpleAuthenticationRequestData::clear_userid() {
	+ userid_.ClearToEmpty();
	+}
	+inline const std::string& SimpleAuthenticationRequestData::userid() const {
	+ // @@protoc_insertion_point(field_get:backup.SimpleAuthenticationRequestData.userID)
	+ return _internal_userid();
	+}
	+inline void SimpleAuthenticationRequestData::set_userid(const std::string& value) {
	+ _internal_set_userid(value);
	+ // @@protoc_insertion_point(field_set:backup.SimpleAuthenticationRequestData.userID)
	+}
	+inline std::string* SimpleAuthenticationRequestData::mutable_userid() {
	+ // @@protoc_insertion_point(field_mutable:backup.SimpleAuthenticationRequestData.userID)
	+ return _internal_mutable_userid();
	+}
	+inline const std::string& SimpleAuthenticationRequestData::_internal_userid() const {
	+ return userid_.Get();
	+}
	+inline void SimpleAuthenticationRequestData::_internal_set_userid(const std::string& value) {

	userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void ResetKeyRequest::set_userid(std::string&& value) {
	+inline void SimpleAuthenticationRequestData::set_userid(std::string&& value) {

	userid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.userId)
	+ // @@protoc_insertion_point(field_set_rvalue:backup.SimpleAuthenticationRequestData.userID)
	}
	-inline void ResetKeyRequest::set_userid(const char* value) {
	+inline void SimpleAuthenticationRequestData::set_userid(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.userId)
	+ // @@protoc_insertion_point(field_set_char:backup.SimpleAuthenticationRequestData.userID)
	}
	-inline void ResetKeyRequest::set_userid(const char* value,
	+inline void SimpleAuthenticationRequestData::set_userid(const char* value,
	size_t size) {

	userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.userId)
	+ // @@protoc_insertion_point(field_set_pointer:backup.SimpleAuthenticationRequestData.userID)
	}
	-inline std::string* ResetKeyRequest::_internal_mutable_userid() {
	+inline std::string* SimpleAuthenticationRequestData::_internal_mutable_userid() {

	return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* ResetKeyRequest::release_userid() {
	- // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.userId)
	+inline std::string* SimpleAuthenticationRequestData::release_userid() {
	+ // @@protoc_insertion_point(field_release:backup.SimpleAuthenticationRequestData.userID)
	return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void ResetKeyRequest::set_allocated_userid(std::string* userid) {
	+inline void SimpleAuthenticationRequestData::set_allocated_userid(std::string* userid) {
	if (userid != nullptr) {

	} else {
	@@ -1180,720 +3618,1337 @@
	}
	userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.userId)
	+ // @@protoc_insertion_point(field_set_allocated:backup.SimpleAuthenticationRequestData.userID)
	}

	-// bytes newKey = 2;
	-inline bool ResetKeyRequest::_internal_has_newkey() const {
	- return data_case() == kNewKey;
	+// -------------------------------------------------------------------
	+
	+// AuthenticationInformationData
	+
	+// bytes nonce = 1;
	+inline bool AuthenticationInformationData::_internal_has_nonce() const {
	+ return data_case() == kNonce;
	}
	-inline bool ResetKeyRequest::has_newkey() const {
	- return _internal_has_newkey();
	+inline bool AuthenticationInformationData::has_nonce() const {
	+ return _internal_has_nonce();
	}
	-inline void ResetKeyRequest::set_has_newkey() {
	- _oneof_case_[0] = kNewKey;
	+inline void AuthenticationInformationData::set_has_nonce() {
	+ _oneof_case_[0] = kNonce;
	}
	-inline void ResetKeyRequest::clear_newkey() {
	- if (_internal_has_newkey()) {
	- data_.newkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+inline void AuthenticationInformationData::clear_nonce() {
	+ if (_internal_has_nonce()) {
	+ data_.nonce_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	clear_has_data();
	}
	}
	-inline const std::string& ResetKeyRequest::newkey() const {
	- // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.newKey)
	- return _internal_newkey();
	+inline const std::string& AuthenticationInformationData::nonce() const {
	+ // @@protoc_insertion_point(field_get:backup.AuthenticationInformationData.nonce)
	+ return _internal_nonce();
	}
	-inline void ResetKeyRequest::set_newkey(const std::string& value) {
	- _internal_set_newkey(value);
	- // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.newKey)
	+inline void AuthenticationInformationData::set_nonce(const std::string& value) {
	+ _internal_set_nonce(value);
	+ // @@protoc_insertion_point(field_set:backup.AuthenticationInformationData.nonce)
	}
	-inline std::string* ResetKeyRequest::mutable_newkey() {
	- // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.newKey)
	- return _internal_mutable_newkey();
	+inline std::string* AuthenticationInformationData::mutable_nonce() {
	+ // @@protoc_insertion_point(field_mutable:backup.AuthenticationInformationData.nonce)
	+ return _internal_mutable_nonce();
	}
	-inline const std::string& ResetKeyRequest::_internal_newkey() const {
	- if (_internal_has_newkey()) {
	- return data_.newkey_.Get();
	+inline const std::string& AuthenticationInformationData::_internal_nonce() const {
	+ if (_internal_has_nonce()) {
	+ return data_.nonce_.Get();
	}
	return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	}
	-inline void ResetKeyRequest::_internal_set_newkey(const std::string& value) {
	- if (!_internal_has_newkey()) {
	+inline void AuthenticationInformationData::_internal_set_nonce(const std::string& value) {
	+ if (!_internal_has_nonce()) {
	clear_data();
	- set_has_newkey();
	- data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ set_has_nonce();
	+ data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	}
	- data_.newkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ data_.nonce_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void ResetKeyRequest::set_newkey(std::string&& value) {
	- // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.newKey)
	- if (!_internal_has_newkey()) {
	+inline void AuthenticationInformationData::set_nonce(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.AuthenticationInformationData.nonce)
	+ if (!_internal_has_nonce()) {
	clear_data();
	- set_has_newkey();
	- data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ set_has_nonce();
	+ data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	}
	- data_.newkey_.Set(
	+ data_.nonce_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.newKey)
	+ // @@protoc_insertion_point(field_set_rvalue:backup.AuthenticationInformationData.nonce)
	}
	-inline void ResetKeyRequest::set_newkey(const char* value) {
	+inline void AuthenticationInformationData::set_nonce(const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	- if (!_internal_has_newkey()) {
	+ if (!_internal_has_nonce()) {
	clear_data();
	- set_has_newkey();
	- data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ set_has_nonce();
	+ data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	}
	- data_.newkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ data_.nonce_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.newKey)
	+ // @@protoc_insertion_point(field_set_char:backup.AuthenticationInformationData.nonce)
	}
	-inline void ResetKeyRequest::set_newkey(const void* value,
	+inline void AuthenticationInformationData::set_nonce(const void* value,
	size_t size) {
	- if (!_internal_has_newkey()) {
	+ if (!_internal_has_nonce()) {
	clear_data();
	- set_has_newkey();
	- data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ set_has_nonce();
	+ data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	}
	- data_.newkey_.Set(
	+ data_.nonce_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size),
	GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.newKey)
	+ // @@protoc_insertion_point(field_set_pointer:backup.AuthenticationInformationData.nonce)
	}
	-inline std::string* ResetKeyRequest::_internal_mutable_newkey() {
	- if (!_internal_has_newkey()) {
	+inline std::string* AuthenticationInformationData::_internal_mutable_nonce() {
	+ if (!_internal_has_nonce()) {
	clear_data();
	- set_has_newkey();
	- data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ set_has_nonce();
	+ data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	}
	- return data_.newkey_.Mutable(
	+ return data_.nonce_.Mutable(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* ResetKeyRequest::release_newkey() {
	- // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.newKey)
	- if (_internal_has_newkey()) {
	+inline std::string* AuthenticationInformationData::release_nonce() {
	+ // @@protoc_insertion_point(field_release:backup.AuthenticationInformationData.nonce)
	+ if (_internal_has_nonce()) {
	clear_has_data();
	- return data_.newkey_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ return data_.nonce_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	} else {
	return nullptr;
	}
	}
	-inline void ResetKeyRequest::set_allocated_newkey(std::string* newkey) {
	+inline void AuthenticationInformationData::set_allocated_nonce(std::string* nonce) {
	if (has_data()) {
	clear_data();
	}
	- if (newkey != nullptr) {
	- set_has_newkey();
	- data_.newkey_.UnsafeSetDefault(newkey);
	+ if (nonce != nullptr) {
	+ set_has_nonce();
	+ data_.nonce_.UnsafeSetDefault(nonce);
	::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	if (arena != nullptr) {
	- arena->Own(newkey);
	+ arena->Own(nonce);
	}
	}
	- // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.newKey)
	+ // @@protoc_insertion_point(field_set_allocated:backup.AuthenticationInformationData.nonce)
	}

	-// bytes compactionChunk = 3;
	-inline bool ResetKeyRequest::_internal_has_compactionchunk() const {
	- return data_case() == kCompactionChunk;
	+// bytes rawMessage = 2;
	+inline bool AuthenticationInformationData::_internal_has_rawmessage() const {
	+ return data_case() == kRawMessage;
	}
	-inline bool ResetKeyRequest::has_compactionchunk() const {
	- return _internal_has_compactionchunk();
	+inline bool AuthenticationInformationData::has_rawmessage() const {
	+ return _internal_has_rawmessage();
	+}
	+inline void AuthenticationInformationData::set_has_rawmessage() {
	+ _oneof_case_[0] = kRawMessage;
	+}
	+inline void AuthenticationInformationData::clear_rawmessage() {
	+ if (_internal_has_rawmessage()) {
	+ data_.rawmessage_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_data();
	+ }
	+}
	+inline const std::string& AuthenticationInformationData::rawmessage() const {
	+ // @@protoc_insertion_point(field_get:backup.AuthenticationInformationData.rawMessage)
	+ return _internal_rawmessage();
	+}
	+inline void AuthenticationInformationData::set_rawmessage(const std::string& value) {
	+ _internal_set_rawmessage(value);
	+ // @@protoc_insertion_point(field_set:backup.AuthenticationInformationData.rawMessage)
	+}
	+inline std::string* AuthenticationInformationData::mutable_rawmessage() {
	+ // @@protoc_insertion_point(field_mutable:backup.AuthenticationInformationData.rawMessage)
	+ return _internal_mutable_rawmessage();
	+}
	+inline const std::string& AuthenticationInformationData::_internal_rawmessage() const {
	+ if (_internal_has_rawmessage()) {
	+ return data_.rawmessage_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void AuthenticationInformationData::_internal_set_rawmessage(const std::string& value) {
	+ if (!_internal_has_rawmessage()) {
	+ clear_data();
	+ set_has_rawmessage();
	+ data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.rawmessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void AuthenticationInformationData::set_rawmessage(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.AuthenticationInformationData.rawMessage)
	+ if (!_internal_has_rawmessage()) {
	+ clear_data();
	+ set_has_rawmessage();
	+ data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.rawmessage_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.AuthenticationInformationData.rawMessage)
	+}
	+inline void AuthenticationInformationData::set_rawmessage(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_rawmessage()) {
	+ clear_data();
	+ set_has_rawmessage();
	+ data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.rawmessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.AuthenticationInformationData.rawMessage)
	+}
	+inline void AuthenticationInformationData::set_rawmessage(const void* value,
	+ size_t size) {
	+ if (!_internal_has_rawmessage()) {
	+ clear_data();
	+ set_has_rawmessage();
	+ data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.rawmessage_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.AuthenticationInformationData.rawMessage)
	+}
	+inline std::string* AuthenticationInformationData::_internal_mutable_rawmessage() {
	+ if (!_internal_has_rawmessage()) {
	+ clear_data();
	+ set_has_rawmessage();
	+ data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return data_.rawmessage_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* AuthenticationInformationData::release_rawmessage() {
	+ // @@protoc_insertion_point(field_release:backup.AuthenticationInformationData.rawMessage)
	+ if (_internal_has_rawmessage()) {
	+ clear_has_data();
	+ return data_.rawmessage_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void AuthenticationInformationData::set_allocated_rawmessage(std::string* rawmessage) {
	+ if (has_data()) {
	+ clear_data();
	+ }
	+ if (rawmessage != nullptr) {
	+ set_has_rawmessage();
	+ data_.rawmessage_.UnsafeSetDefault(rawmessage);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(rawmessage);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.AuthenticationInformationData.rawMessage)
	+}
	+
	+inline bool AuthenticationInformationData::has_data() const {
	+ return data_case() != DATA_NOT_SET;
	+}
	+inline void AuthenticationInformationData::clear_has_data() {
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+inline AuthenticationInformationData::DataCase AuthenticationInformationData::data_case() const {
	+ return AuthenticationInformationData::DataCase(_oneof_case_[0]);
	+}
	+// -------------------------------------------------------------------
	+
	+// CreateNewBackupRequest
	+
	+// .backup.FullAuthenticationRequestData authenticationRequestData = 1;
	+inline bool CreateNewBackupRequest::_internal_has_authenticationrequestdata() const {
	+ return data_case() == kAuthenticationRequestData;
	+}
	+inline bool CreateNewBackupRequest::has_authenticationrequestdata() const {
	+ return _internal_has_authenticationrequestdata();
	+}
	+inline void CreateNewBackupRequest::set_has_authenticationrequestdata() {
	+ _oneof_case_[0] = kAuthenticationRequestData;
	+}
	+inline void CreateNewBackupRequest::clear_authenticationrequestdata() {
	+ if (_internal_has_authenticationrequestdata()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.authenticationrequestdata_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::release_authenticationrequestdata() {
	+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.authenticationRequestData)
	+ if (_internal_has_authenticationrequestdata()) {
	+ clear_has_data();
	+ ::backup::FullAuthenticationRequestData* temp = data_.authenticationrequestdata_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.authenticationrequestdata_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::backup::FullAuthenticationRequestData& CreateNewBackupRequest::_internal_authenticationrequestdata() const {
	+ return _internal_has_authenticationrequestdata()
	+ ? *data_.authenticationrequestdata_
	+ : reinterpret_cast< ::backup::FullAuthenticationRequestData&>(::backup::_FullAuthenticationRequestData_default_instance_);
	+}
	+inline const ::backup::FullAuthenticationRequestData& CreateNewBackupRequest::authenticationrequestdata() const {
	+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.authenticationRequestData)
	+ return _internal_authenticationrequestdata();
	+}
	+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::unsafe_arena_release_authenticationrequestdata() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.CreateNewBackupRequest.authenticationRequestData)
	+ if (_internal_has_authenticationrequestdata()) {
	+ clear_has_data();
	+ ::backup::FullAuthenticationRequestData* temp = data_.authenticationrequestdata_;
	+ data_.authenticationrequestdata_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void CreateNewBackupRequest::unsafe_arena_set_allocated_authenticationrequestdata(::backup::FullAuthenticationRequestData* authenticationrequestdata) {
	+ clear_data();
	+ if (authenticationrequestdata) {
	+ set_has_authenticationrequestdata();
	+ data_.authenticationrequestdata_ = authenticationrequestdata;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.CreateNewBackupRequest.authenticationRequestData)
	+}
	+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::_internal_mutable_authenticationrequestdata() {
	+ if (!_internal_has_authenticationrequestdata()) {
	+ clear_data();
	+ set_has_authenticationrequestdata();
	+ data_.authenticationrequestdata_ = CreateMaybeMessage< ::backup::FullAuthenticationRequestData >(GetArena());
	+ }
	+ return data_.authenticationrequestdata_;
	+}
	+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::mutable_authenticationrequestdata() {
	+ // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.authenticationRequestData)
	+ return _internal_mutable_authenticationrequestdata();
	+}
	+
	+// .backup.AuthenticationInformationData authenticationInformationData = 2;
	+inline bool CreateNewBackupRequest::_internal_has_authenticationinformationdata() const {
	+ return data_case() == kAuthenticationInformationData;
	+}
	+inline bool CreateNewBackupRequest::has_authenticationinformationdata() const {
	+ return _internal_has_authenticationinformationdata();
	+}
	+inline void CreateNewBackupRequest::set_has_authenticationinformationdata() {
	+ _oneof_case_[0] = kAuthenticationInformationData;
	+}
	+inline void CreateNewBackupRequest::clear_authenticationinformationdata() {
	+ if (_internal_has_authenticationinformationdata()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.authenticationinformationdata_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::backup::AuthenticationInformationData* CreateNewBackupRequest::release_authenticationinformationdata() {
	+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.authenticationInformationData)
	+ if (_internal_has_authenticationinformationdata()) {
	+ clear_has_data();
	+ ::backup::AuthenticationInformationData* temp = data_.authenticationinformationdata_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.authenticationinformationdata_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::backup::AuthenticationInformationData& CreateNewBackupRequest::_internal_authenticationinformationdata() const {
	+ return _internal_has_authenticationinformationdata()
	+ ? *data_.authenticationinformationdata_
	+ : reinterpret_cast< ::backup::AuthenticationInformationData&>(::backup::_AuthenticationInformationData_default_instance_);
	+}
	+inline const ::backup::AuthenticationInformationData& CreateNewBackupRequest::authenticationinformationdata() const {
	+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.authenticationInformationData)
	+ return _internal_authenticationinformationdata();
	+}
	+inline ::backup::AuthenticationInformationData* CreateNewBackupRequest::unsafe_arena_release_authenticationinformationdata() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.CreateNewBackupRequest.authenticationInformationData)
	+ if (_internal_has_authenticationinformationdata()) {
	+ clear_has_data();
	+ ::backup::AuthenticationInformationData* temp = data_.authenticationinformationdata_;
	+ data_.authenticationinformationdata_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void CreateNewBackupRequest::unsafe_arena_set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata) {
	+ clear_data();
	+ if (authenticationinformationdata) {
	+ set_has_authenticationinformationdata();
	+ data_.authenticationinformationdata_ = authenticationinformationdata;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.CreateNewBackupRequest.authenticationInformationData)
	+}
	+inline ::backup::AuthenticationInformationData* CreateNewBackupRequest::_internal_mutable_authenticationinformationdata() {
	+ if (!_internal_has_authenticationinformationdata()) {
	+ clear_data();
	+ set_has_authenticationinformationdata();
	+ data_.authenticationinformationdata_ = CreateMaybeMessage< ::backup::AuthenticationInformationData >(GetArena());
	+ }
	+ return data_.authenticationinformationdata_;
	+}
	+inline ::backup::AuthenticationInformationData* CreateNewBackupRequest::mutable_authenticationinformationdata() {
	+ // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.authenticationInformationData)
	+ return _internal_mutable_authenticationinformationdata();
	+}
	+
	+// bytes newCompactionChunk = 3;
	+inline bool CreateNewBackupRequest::_internal_has_newcompactionchunk() const {
	+ return data_case() == kNewCompactionChunk;
	+}
	+inline bool CreateNewBackupRequest::has_newcompactionchunk() const {
	+ return _internal_has_newcompactionchunk();
	+}
	+inline void CreateNewBackupRequest::set_has_newcompactionchunk() {
	+ _oneof_case_[0] = kNewCompactionChunk;
	+}
	+inline void CreateNewBackupRequest::clear_newcompactionchunk() {
	+ if (_internal_has_newcompactionchunk()) {
	+ data_.newcompactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_data();
	+ }
	+}
	+inline const std::string& CreateNewBackupRequest::newcompactionchunk() const {
	+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.newCompactionChunk)
	+ return _internal_newcompactionchunk();
	+}
	+inline void CreateNewBackupRequest::set_newcompactionchunk(const std::string& value) {
	+ _internal_set_newcompactionchunk(value);
	+ // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.newCompactionChunk)
	+}
	+inline std::string* CreateNewBackupRequest::mutable_newcompactionchunk() {
	+ // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.newCompactionChunk)
	+ return _internal_mutable_newcompactionchunk();
	+}
	+inline const std::string& CreateNewBackupRequest::_internal_newcompactionchunk() const {
	+ if (_internal_has_newcompactionchunk()) {
	+ return data_.newcompactionchunk_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void CreateNewBackupRequest::_internal_set_newcompactionchunk(const std::string& value) {
	+ if (!_internal_has_newcompactionchunk()) {
	+ clear_data();
	+ set_has_newcompactionchunk();
	+ data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.newcompactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void CreateNewBackupRequest::set_newcompactionchunk(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.newCompactionChunk)
	+ if (!_internal_has_newcompactionchunk()) {
	+ clear_data();
	+ set_has_newcompactionchunk();
	+ data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.newcompactionchunk_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupRequest.newCompactionChunk)
	+}
	+inline void CreateNewBackupRequest::set_newcompactionchunk(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_newcompactionchunk()) {
	+ clear_data();
	+ set_has_newcompactionchunk();
	+ data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.newcompactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupRequest.newCompactionChunk)
	+}
	+inline void CreateNewBackupRequest::set_newcompactionchunk(const void* value,
	+ size_t size) {
	+ if (!_internal_has_newcompactionchunk()) {
	+ clear_data();
	+ set_has_newcompactionchunk();
	+ data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.newcompactionchunk_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupRequest.newCompactionChunk)
	+}
	+inline std::string* CreateNewBackupRequest::_internal_mutable_newcompactionchunk() {
	+ if (!_internal_has_newcompactionchunk()) {
	+ clear_data();
	+ set_has_newcompactionchunk();
	+ data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return data_.newcompactionchunk_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* CreateNewBackupRequest::release_newcompactionchunk() {
	+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.newCompactionChunk)
	+ if (_internal_has_newcompactionchunk()) {
	+ clear_has_data();
	+ return data_.newcompactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void CreateNewBackupRequest::set_allocated_newcompactionchunk(std::string* newcompactionchunk) {
	+ if (has_data()) {
	+ clear_data();
	+ }
	+ if (newcompactionchunk != nullptr) {
	+ set_has_newcompactionchunk();
	+ data_.newcompactionchunk_.UnsafeSetDefault(newcompactionchunk);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(newcompactionchunk);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.newCompactionChunk)
	+}
	+
	+inline bool CreateNewBackupRequest::has_data() const {
	+ return data_case() != DATA_NOT_SET;
	+}
	+inline void CreateNewBackupRequest::clear_has_data() {
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+inline CreateNewBackupRequest::DataCase CreateNewBackupRequest::data_case() const {
	+ return CreateNewBackupRequest::DataCase(_oneof_case_[0]);
	+}
	+// -------------------------------------------------------------------
	+
	+// CreateNewBackupResponse
	+
	+// .backup.FullAuthenticationResponseData authenticationResponseData = 1;
	+inline bool CreateNewBackupResponse::_internal_has_authenticationresponsedata() const {
	+ return data_case() == kAuthenticationResponseData;
	+}
	+inline bool CreateNewBackupResponse::has_authenticationresponsedata() const {
	+ return _internal_has_authenticationresponsedata();
	+}
	+inline void CreateNewBackupResponse::set_has_authenticationresponsedata() {
	+ _oneof_case_[0] = kAuthenticationResponseData;
	+}
	+inline void CreateNewBackupResponse::clear_authenticationresponsedata() {
	+ if (_internal_has_authenticationresponsedata()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.authenticationresponsedata_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::release_authenticationresponsedata() {
	+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupResponse.authenticationResponseData)
	+ if (_internal_has_authenticationresponsedata()) {
	+ clear_has_data();
	+ ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.authenticationresponsedata_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::backup::FullAuthenticationResponseData& CreateNewBackupResponse::_internal_authenticationresponsedata() const {
	+ return _internal_has_authenticationresponsedata()
	+ ? *data_.authenticationresponsedata_
	+ : reinterpret_cast< ::backup::FullAuthenticationResponseData&>(::backup::_FullAuthenticationResponseData_default_instance_);
	+}
	+inline const ::backup::FullAuthenticationResponseData& CreateNewBackupResponse::authenticationresponsedata() const {
	+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.authenticationResponseData)
	+ return _internal_authenticationresponsedata();
	+}
	+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::unsafe_arena_release_authenticationresponsedata() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.CreateNewBackupResponse.authenticationResponseData)
	+ if (_internal_has_authenticationresponsedata()) {
	+ clear_has_data();
	+ ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
	+ data_.authenticationresponsedata_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void CreateNewBackupResponse::unsafe_arena_set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
	+ clear_data();
	+ if (authenticationresponsedata) {
	+ set_has_authenticationresponsedata();
	+ data_.authenticationresponsedata_ = authenticationresponsedata;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.CreateNewBackupResponse.authenticationResponseData)
	+}
	+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::_internal_mutable_authenticationresponsedata() {
	+ if (!_internal_has_authenticationresponsedata()) {
	+ clear_data();
	+ set_has_authenticationresponsedata();
	+ data_.authenticationresponsedata_ = CreateMaybeMessage< ::backup::FullAuthenticationResponseData >(GetArena());
	+ }
	+ return data_.authenticationresponsedata_;
	+}
	+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::mutable_authenticationresponsedata() {
	+ // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupResponse.authenticationResponseData)
	+ return _internal_mutable_authenticationresponsedata();
	+}
	+
	+// string backupID = 2;
	+inline bool CreateNewBackupResponse::_internal_has_backupid() const {
	+ return data_case() == kBackupID;
	+}
	+inline bool CreateNewBackupResponse::has_backupid() const {
	+ return _internal_has_backupid();
	}
	-inline void ResetKeyRequest::set_has_compactionchunk() {
	- _oneof_case_[0] = kCompactionChunk;
	+inline void CreateNewBackupResponse::set_has_backupid() {
	+ _oneof_case_[0] = kBackupID;
	}
	-inline void ResetKeyRequest::clear_compactionchunk() {
	- if (_internal_has_compactionchunk()) {
	- data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+inline void CreateNewBackupResponse::clear_backupid() {
	+ if (_internal_has_backupid()) {
	+ data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	clear_has_data();
	}
	}
	-inline const std::string& ResetKeyRequest::compactionchunk() const {
	- // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.compactionChunk)
	- return _internal_compactionchunk();
	+inline const std::string& CreateNewBackupResponse::backupid() const {
	+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.backupID)
	+ return _internal_backupid();
	}
	-inline void ResetKeyRequest::set_compactionchunk(const std::string& value) {
	- _internal_set_compactionchunk(value);
	- // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.compactionChunk)
	+inline void CreateNewBackupResponse::set_backupid(const std::string& value) {
	+ _internal_set_backupid(value);
	+ // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.backupID)
	}
	-inline std::string* ResetKeyRequest::mutable_compactionchunk() {
	- // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.compactionChunk)
	- return _internal_mutable_compactionchunk();
	+inline std::string* CreateNewBackupResponse::mutable_backupid() {
	+ // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupResponse.backupID)
	+ return _internal_mutable_backupid();
	}
	-inline const std::string& ResetKeyRequest::_internal_compactionchunk() const {
	- if (_internal_has_compactionchunk()) {
	- return data_.compactionchunk_.Get();
	+inline const std::string& CreateNewBackupResponse::_internal_backupid() const {
	+ if (_internal_has_backupid()) {
	+ return data_.backupid_.Get();
	}
	return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	}
	-inline void ResetKeyRequest::_internal_set_compactionchunk(const std::string& value) {
	- if (!_internal_has_compactionchunk()) {
	+inline void CreateNewBackupResponse::_internal_set_backupid(const std::string& value) {
	+ if (!_internal_has_backupid()) {
	clear_data();
	- set_has_compactionchunk();
	- data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	}
	- data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void ResetKeyRequest::set_compactionchunk(std::string&& value) {
	- // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.compactionChunk)
	- if (!_internal_has_compactionchunk()) {
	+inline void CreateNewBackupResponse::set_backupid(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.backupID)
	+ if (!_internal_has_backupid()) {
	clear_data();
	- set_has_compactionchunk();
	- data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	}
	- data_.compactionchunk_.Set(
	+ data_.backupid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.compactionChunk)
	+ // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupResponse.backupID)
	}
	-inline void ResetKeyRequest::set_compactionchunk(const char* value) {
	+inline void CreateNewBackupResponse::set_backupid(const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	- if (!_internal_has_compactionchunk()) {
	+ if (!_internal_has_backupid()) {
	clear_data();
	- set_has_compactionchunk();
	- data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	}
	- data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.compactionChunk)
	+ // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupResponse.backupID)
	}
	-inline void ResetKeyRequest::set_compactionchunk(const void* value,
	+inline void CreateNewBackupResponse::set_backupid(const char* value,
	size_t size) {
	- if (!_internal_has_compactionchunk()) {
	+ if (!_internal_has_backupid()) {
	clear_data();
	- set_has_compactionchunk();
	- data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	}
	- data_.compactionchunk_.Set(
	+ data_.backupid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size),
	GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.compactionChunk)
	+ // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupResponse.backupID)
	}
	-inline std::string* ResetKeyRequest::_internal_mutable_compactionchunk() {
	- if (!_internal_has_compactionchunk()) {
	+inline std::string* CreateNewBackupResponse::_internal_mutable_backupid() {
	+ if (!_internal_has_backupid()) {
	clear_data();
	- set_has_compactionchunk();
	- data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	}
	- return data_.compactionchunk_.Mutable(
	+ return data_.backupid_.Mutable(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* ResetKeyRequest::release_compactionchunk() {
	- // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.compactionChunk)
	- if (_internal_has_compactionchunk()) {
	+inline std::string* CreateNewBackupResponse::release_backupid() {
	+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupResponse.backupID)
	+ if (_internal_has_backupid()) {
	clear_has_data();
	- return data_.compactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ return data_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	} else {
	return nullptr;
	}
	}
	-inline void ResetKeyRequest::set_allocated_compactionchunk(std::string* compactionchunk) {
	+inline void CreateNewBackupResponse::set_allocated_backupid(std::string* backupid) {
	if (has_data()) {
	clear_data();
	}
	- if (compactionchunk != nullptr) {
	- set_has_compactionchunk();
	- data_.compactionchunk_.UnsafeSetDefault(compactionchunk);
	+ if (backupid != nullptr) {
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(backupid);
	::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	if (arena != nullptr) {
	- arena->Own(compactionchunk);
	+ arena->Own(backupid);
	}
	}
	- // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.compactionChunk)
	+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupResponse.backupID)
	}

	-inline bool ResetKeyRequest::has_data() const {
	+inline bool CreateNewBackupResponse::has_data() const {
	return data_case() != DATA_NOT_SET;
	}
	-inline void ResetKeyRequest::clear_has_data() {
	+inline void CreateNewBackupResponse::clear_has_data() {
	_oneof_case_[0] = DATA_NOT_SET;
	}
	-inline ResetKeyRequest::DataCase ResetKeyRequest::data_case() const {
	- return ResetKeyRequest::DataCase(_oneof_case_[0]);
	+inline CreateNewBackupResponse::DataCase CreateNewBackupResponse::data_case() const {
	+ return CreateNewBackupResponse::DataCase(_oneof_case_[0]);
	}
	// -------------------------------------------------------------------

	// SendLogRequest

	-// string userId = 1;
	-inline void SendLogRequest::clear_userid() {
	- userid_.ClearToEmpty();
	-}
	-inline const std::string& SendLogRequest::userid() const {
	- // @@protoc_insertion_point(field_get:backup.SendLogRequest.userId)
	- return _internal_userid();
	+// .backup.SimpleAuthenticationRequestData authenticationData = 1;
	+inline bool SendLogRequest::_internal_has_authenticationdata() const {
	+ return this != internal_default_instance() && authenticationdata_ != nullptr;
	}
	-inline void SendLogRequest::set_userid(const std::string& value) {
	- _internal_set_userid(value);
	- // @@protoc_insertion_point(field_set:backup.SendLogRequest.userId)
	+inline bool SendLogRequest::has_authenticationdata() const {
	+ return _internal_has_authenticationdata();
	}
	-inline std::string* SendLogRequest::mutable_userid() {
	- // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.userId)
	- return _internal_mutable_userid();
	+inline void SendLogRequest::clear_authenticationdata() {
	+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
	+ delete authenticationdata_;
	+ }
	+ authenticationdata_ = nullptr;
	}
	-inline const std::string& SendLogRequest::_internal_userid() const {
	- return userid_.Get();
	+inline const ::backup::SimpleAuthenticationRequestData& SendLogRequest::_internal_authenticationdata() const {
	+ const ::backup::SimpleAuthenticationRequestData* p = authenticationdata_;
	+ return p != nullptr ? *p : reinterpret_cast<const ::backup::SimpleAuthenticationRequestData&>(
	+ ::backup::_SimpleAuthenticationRequestData_default_instance_);
	}
	-inline void SendLogRequest::_internal_set_userid(const std::string& value) {
	-
	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+inline const ::backup::SimpleAuthenticationRequestData& SendLogRequest::authenticationdata() const {
	+ // @@protoc_insertion_point(field_get:backup.SendLogRequest.authenticationData)
	+ return _internal_authenticationdata();
	}
	-inline void SendLogRequest::set_userid(std::string&& value) {
	-
	- userid_.Set(
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.userId)
	+inline void SendLogRequest::unsafe_arena_set_allocated_authenticationdata(
	+ ::backup::SimpleAuthenticationRequestData* authenticationdata) {
	+ if (GetArena() == nullptr) {
	+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_);
	+ }
	+ authenticationdata_ = authenticationdata;
	+ if (authenticationdata) {
	+
	+ } else {
	+
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.SendLogRequest.authenticationData)
	}
	-inline void SendLogRequest::set_userid(const char* value) {
	- GOOGLE_DCHECK(value != nullptr);
	+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::release_authenticationdata() {

	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.userId)
	+ ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
	+ authenticationdata_ = nullptr;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ return temp;
	}
	-inline void SendLogRequest::set_userid(const char* value,
	- size_t size) {
	+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::unsafe_arena_release_authenticationdata() {
	+ // @@protoc_insertion_point(field_release:backup.SendLogRequest.authenticationData)

	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	- reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.userId)
	+ ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
	+ authenticationdata_ = nullptr;
	+ return temp;
	}
	-inline std::string* SendLogRequest::_internal_mutable_userid() {
	+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::_internal_mutable_authenticationdata() {

	- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	-}
	-inline std::string* SendLogRequest::release_userid() {
	- // @@protoc_insertion_point(field_release:backup.SendLogRequest.userId)
	- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	-}
	-inline void SendLogRequest::set_allocated_userid(std::string* userid) {
	- if (userid != nullptr) {
	+ if (authenticationdata_ == nullptr) {
	+ auto* p = CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(GetArena());
	+ authenticationdata_ = p;
	+ }
	+ return authenticationdata_;
	+}
	+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::mutable_authenticationdata() {
	+ // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.authenticationData)
	+ return _internal_mutable_authenticationdata();
	+}
	+inline void SendLogRequest::set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ if (message_arena == nullptr) {
	+ delete authenticationdata_;
	+ }
	+ if (authenticationdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata);
	+ if (message_arena != submessage_arena) {
	+ authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, authenticationdata, submessage_arena);
	+ }

	} else {

	}
	- userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
	- GetArena());
	- // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.userId)
	+ authenticationdata_ = authenticationdata;
	+ // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.authenticationData)
	}

	-// bytes data = 2;
	-inline void SendLogRequest::clear_data() {
	- data_.ClearToEmpty();
	+// bytes logData = 2;
	+inline void SendLogRequest::clear_logdata() {
	+ logdata_.ClearToEmpty();
	}
	-inline const std::string& SendLogRequest::data() const {
	- // @@protoc_insertion_point(field_get:backup.SendLogRequest.data)
	- return _internal_data();
	+inline const std::string& SendLogRequest::logdata() const {
	+ // @@protoc_insertion_point(field_get:backup.SendLogRequest.logData)
	+ return _internal_logdata();
	}
	-inline void SendLogRequest::set_data(const std::string& value) {
	- _internal_set_data(value);
	- // @@protoc_insertion_point(field_set:backup.SendLogRequest.data)
	+inline void SendLogRequest::set_logdata(const std::string& value) {
	+ _internal_set_logdata(value);
	+ // @@protoc_insertion_point(field_set:backup.SendLogRequest.logData)
	}
	-inline std::string* SendLogRequest::mutable_data() {
	- // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.data)
	- return _internal_mutable_data();
	+inline std::string* SendLogRequest::mutable_logdata() {
	+ // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.logData)
	+ return _internal_mutable_logdata();
	}
	-inline const std::string& SendLogRequest::_internal_data() const {
	- return data_.Get();
	+inline const std::string& SendLogRequest::_internal_logdata() const {
	+ return logdata_.Get();
	}
	-inline void SendLogRequest::_internal_set_data(const std::string& value) {
	+inline void SendLogRequest::_internal_set_logdata(const std::string& value) {

	- data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void SendLogRequest::set_data(std::string&& value) {
	+inline void SendLogRequest::set_logdata(std::string&& value) {

	- data_.Set(
	+ logdata_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.data)
	+ // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.logData)
	}
	-inline void SendLogRequest::set_data(const char* value) {
	+inline void SendLogRequest::set_logdata(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	- data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.data)
	+ logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.logData)
	}
	-inline void SendLogRequest::set_data(const void* value,
	+inline void SendLogRequest::set_logdata(const void* value,
	size_t size) {

	- data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.data)
	+ // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.logData)
	}
	-inline std::string* SendLogRequest::_internal_mutable_data() {
	+inline std::string* SendLogRequest::_internal_mutable_logdata() {

	- return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ return logdata_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* SendLogRequest::release_data() {
	- // @@protoc_insertion_point(field_release:backup.SendLogRequest.data)
	- return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* SendLogRequest::release_logdata() {
	+ // @@protoc_insertion_point(field_release:backup.SendLogRequest.logData)
	+ return logdata_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void SendLogRequest::set_allocated_data(std::string* data) {
	- if (data != nullptr) {
	+inline void SendLogRequest::set_allocated_logdata(std::string* logdata) {
	+ if (logdata != nullptr) {

	} else {

	}
	- data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
	+ logdata_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), logdata,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.data)
	+ // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.logData)
	}

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

	-// PullBackupKeyRequest
	+// RecoverBackupKeyRequest

	-// string userId = 1;
	-inline void PullBackupKeyRequest::clear_userid() {
	- userid_.ClearToEmpty();
	-}
	-inline const std::string& PullBackupKeyRequest::userid() const {
	- // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.userId)
	- return _internal_userid();
	+// .backup.FullAuthenticationRequestData authenticationData = 1;
	+inline bool RecoverBackupKeyRequest::_internal_has_authenticationdata() const {
	+ return this != internal_default_instance() && authenticationdata_ != nullptr;
	}
	-inline void PullBackupKeyRequest::set_userid(const std::string& value) {
	- _internal_set_userid(value);
	- // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.userId)
	+inline bool RecoverBackupKeyRequest::has_authenticationdata() const {
	+ return _internal_has_authenticationdata();
	}
	-inline std::string* PullBackupKeyRequest::mutable_userid() {
	- // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.userId)
	- return _internal_mutable_userid();
	+inline void RecoverBackupKeyRequest::clear_authenticationdata() {
	+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
	+ delete authenticationdata_;
	+ }
	+ authenticationdata_ = nullptr;
	}
	-inline const std::string& PullBackupKeyRequest::_internal_userid() const {
	- return userid_.Get();
	+inline const ::backup::FullAuthenticationRequestData& RecoverBackupKeyRequest::_internal_authenticationdata() const {
	+ const ::backup::FullAuthenticationRequestData* p = authenticationdata_;
	+ return p != nullptr ? *p : reinterpret_cast<const ::backup::FullAuthenticationRequestData&>(
	+ ::backup::_FullAuthenticationRequestData_default_instance_);
	}
	-inline void PullBackupKeyRequest::_internal_set_userid(const std::string& value) {
	-
	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+inline const ::backup::FullAuthenticationRequestData& RecoverBackupKeyRequest::authenticationdata() const {
	+ // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyRequest.authenticationData)
	+ return _internal_authenticationdata();
	}
	-inline void PullBackupKeyRequest::set_userid(std::string&& value) {
	-
	- userid_.Set(
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.userId)
	+inline void RecoverBackupKeyRequest::unsafe_arena_set_allocated_authenticationdata(
	+ ::backup::FullAuthenticationRequestData* authenticationdata) {
	+ if (GetArena() == nullptr) {
	+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_);
	+ }
	+ authenticationdata_ = authenticationdata;
	+ if (authenticationdata) {
	+
	+ } else {
	+
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.RecoverBackupKeyRequest.authenticationData)
	}
	-inline void PullBackupKeyRequest::set_userid(const char* value) {
	- GOOGLE_DCHECK(value != nullptr);
	+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::release_authenticationdata() {

	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.userId)
	+ ::backup::FullAuthenticationRequestData* temp = authenticationdata_;
	+ authenticationdata_ = nullptr;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ return temp;
	}
	-inline void PullBackupKeyRequest::set_userid(const char* value,
	- size_t size) {
	+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::unsafe_arena_release_authenticationdata() {
	+ // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyRequest.authenticationData)

	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	- reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyRequest.userId)
	+ ::backup::FullAuthenticationRequestData* temp = authenticationdata_;
	+ authenticationdata_ = nullptr;
	+ return temp;
	}
	-inline std::string* PullBackupKeyRequest::_internal_mutable_userid() {
	+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::_internal_mutable_authenticationdata() {

	- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	-}
	-inline std::string* PullBackupKeyRequest::release_userid() {
	- // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.userId)
	- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	-}
	-inline void PullBackupKeyRequest::set_allocated_userid(std::string* userid) {
	- if (userid != nullptr) {
	+ if (authenticationdata_ == nullptr) {
	+ auto* p = CreateMaybeMessage<::backup::FullAuthenticationRequestData>(GetArena());
	+ authenticationdata_ = p;
	+ }
	+ return authenticationdata_;
	+}
	+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::mutable_authenticationdata() {
	+ // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyRequest.authenticationData)
	+ return _internal_mutable_authenticationdata();
	+}
	+inline void RecoverBackupKeyRequest::set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ if (message_arena == nullptr) {
	+ delete authenticationdata_;
	+ }
	+ if (authenticationdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata);
	+ if (message_arena != submessage_arena) {
	+ authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, authenticationdata, submessage_arena);
	+ }

	} else {

	}
	- userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
	- GetArena());
	- // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.userId)
	+ authenticationdata_ = authenticationdata;
	+ // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyRequest.authenticationData)
	}

	-// bytes pakeKey = 2;
	-inline void PullBackupKeyRequest::clear_pakekey() {
	- pakekey_.ClearToEmpty();
	-}
	-inline const std::string& PullBackupKeyRequest::pakekey() const {
	- // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.pakeKey)
	- return _internal_pakekey();
	-}
	-inline void PullBackupKeyRequest::set_pakekey(const std::string& value) {
	- _internal_set_pakekey(value);
	- // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.pakeKey)
	-}
	-inline std::string* PullBackupKeyRequest::mutable_pakekey() {
	- // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.pakeKey)
	- return _internal_mutable_pakekey();
	-}
	-inline const std::string& PullBackupKeyRequest::_internal_pakekey() const {
	- return pakekey_.Get();
	+// -------------------------------------------------------------------
	+
	+// RecoverBackupKeyResponse
	+
	+// .backup.FullAuthenticationResponseData authenticationResponseData = 1;
	+inline bool RecoverBackupKeyResponse::_internal_has_authenticationresponsedata() const {
	+ return data_case() == kAuthenticationResponseData;
	}
	-inline void PullBackupKeyRequest::_internal_set_pakekey(const std::string& value) {
	-
	- pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+inline bool RecoverBackupKeyResponse::has_authenticationresponsedata() const {
	+ return _internal_has_authenticationresponsedata();
	}
	-inline void PullBackupKeyRequest::set_pakekey(std::string&& value) {
	-
	- pakekey_.Set(
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.pakeKey)
	+inline void RecoverBackupKeyResponse::set_has_authenticationresponsedata() {
	+ _oneof_case_[0] = kAuthenticationResponseData;
	}
	-inline void PullBackupKeyRequest::set_pakekey(const char* value) {
	- GOOGLE_DCHECK(value != nullptr);
	-
	- pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.pakeKey)
	+inline void RecoverBackupKeyResponse::clear_authenticationresponsedata() {
	+ if (_internal_has_authenticationresponsedata()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.authenticationresponsedata_;
	+ }
	+ clear_has_data();
	+ }
	}
	-inline void PullBackupKeyRequest::set_pakekey(const void* value,
	- size_t size) {
	-
	- pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	- reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyRequest.pakeKey)
	+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::release_authenticationresponsedata() {
	+ // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyResponse.authenticationResponseData)
	+ if (_internal_has_authenticationresponsedata()) {
	+ clear_has_data();
	+ ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.authenticationresponsedata_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	}
	-inline std::string* PullBackupKeyRequest::_internal_mutable_pakekey() {
	-
	- return pakekey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+inline const ::backup::FullAuthenticationResponseData& RecoverBackupKeyResponse::_internal_authenticationresponsedata() const {
	+ return _internal_has_authenticationresponsedata()
	+ ? *data_.authenticationresponsedata_
	+ : reinterpret_cast< ::backup::FullAuthenticationResponseData&>(::backup::_FullAuthenticationResponseData_default_instance_);
	}
	-inline std::string* PullBackupKeyRequest::release_pakekey() {
	- // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.pakeKey)
	- return pakekey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline const ::backup::FullAuthenticationResponseData& RecoverBackupKeyResponse::authenticationresponsedata() const {
	+ // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyResponse.authenticationResponseData)
	+ return _internal_authenticationresponsedata();
	}
	-inline void PullBackupKeyRequest::set_allocated_pakekey(std::string* pakekey) {
	- if (pakekey != nullptr) {
	-
	+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::unsafe_arena_release_authenticationresponsedata() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.RecoverBackupKeyResponse.authenticationResponseData)
	+ if (_internal_has_authenticationresponsedata()) {
	+ clear_has_data();
	+ ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
	+ data_.authenticationresponsedata_ = nullptr;
	+ return temp;
	} else {
	-
	+ return nullptr;
	}
	- pakekey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakekey,
	- GetArena());
	- // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.pakeKey)
	-}
	-
	-// -------------------------------------------------------------------
	-
	-// PullBackupKeyResponse
	-
	-// bytes encryptedBackupKey = 1;
	-inline void PullBackupKeyResponse::clear_encryptedbackupkey() {
	- encryptedbackupkey_.ClearToEmpty();
	}
	-inline const std::string& PullBackupKeyResponse::encryptedbackupkey() const {
	- // @@protoc_insertion_point(field_get:backup.PullBackupKeyResponse.encryptedBackupKey)
	- return _internal_encryptedbackupkey();
	+inline void RecoverBackupKeyResponse::unsafe_arena_set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
	+ clear_data();
	+ if (authenticationresponsedata) {
	+ set_has_authenticationresponsedata();
	+ data_.authenticationresponsedata_ = authenticationresponsedata;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.RecoverBackupKeyResponse.authenticationResponseData)
	}
	-inline void PullBackupKeyResponse::set_encryptedbackupkey(const std::string& value) {
	- _internal_set_encryptedbackupkey(value);
	- // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.encryptedBackupKey)
	+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::_internal_mutable_authenticationresponsedata() {
	+ if (!_internal_has_authenticationresponsedata()) {
	+ clear_data();
	+ set_has_authenticationresponsedata();
	+ data_.authenticationresponsedata_ = CreateMaybeMessage< ::backup::FullAuthenticationResponseData >(GetArena());
	+ }
	+ return data_.authenticationresponsedata_;
	}
	-inline std::string* PullBackupKeyResponse::mutable_encryptedbackupkey() {
	- // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyResponse.encryptedBackupKey)
	- return _internal_mutable_encryptedbackupkey();
	+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::mutable_authenticationresponsedata() {
	+ // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyResponse.authenticationResponseData)
	+ return _internal_mutable_authenticationresponsedata();
	}
	-inline const std::string& PullBackupKeyResponse::_internal_encryptedbackupkey() const {
	- return encryptedbackupkey_.Get();
	+
	+// .backup.AuthenticationInformationData authenticationInformationData = 2;
	+inline bool RecoverBackupKeyResponse::_internal_has_authenticationinformationdata() const {
	+ return data_case() == kAuthenticationInformationData;
	}
	-inline void PullBackupKeyResponse::_internal_set_encryptedbackupkey(const std::string& value) {
	-
	- encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+inline bool RecoverBackupKeyResponse::has_authenticationinformationdata() const {
	+ return _internal_has_authenticationinformationdata();
	}
	-inline void PullBackupKeyResponse::set_encryptedbackupkey(std::string&& value) {
	-
	- encryptedbackupkey_.Set(
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyResponse.encryptedBackupKey)
	+inline void RecoverBackupKeyResponse::set_has_authenticationinformationdata() {
	+ _oneof_case_[0] = kAuthenticationInformationData;
	}
	-inline void PullBackupKeyResponse::set_encryptedbackupkey(const char* value) {
	- GOOGLE_DCHECK(value != nullptr);
	-
	- encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyResponse.encryptedBackupKey)
	+inline void RecoverBackupKeyResponse::clear_authenticationinformationdata() {
	+ if (_internal_has_authenticationinformationdata()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.authenticationinformationdata_;
	+ }
	+ clear_has_data();
	+ }
	}
	-inline void PullBackupKeyResponse::set_encryptedbackupkey(const void* value,
	- size_t size) {
	-
	- encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	- reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyResponse.encryptedBackupKey)
	+inline ::backup::AuthenticationInformationData* RecoverBackupKeyResponse::release_authenticationinformationdata() {
	+ // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyResponse.authenticationInformationData)
	+ if (_internal_has_authenticationinformationdata()) {
	+ clear_has_data();
	+ ::backup::AuthenticationInformationData* temp = data_.authenticationinformationdata_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.authenticationinformationdata_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	}
	-inline std::string* PullBackupKeyResponse::_internal_mutable_encryptedbackupkey() {
	-
	- return encryptedbackupkey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+inline const ::backup::AuthenticationInformationData& RecoverBackupKeyResponse::_internal_authenticationinformationdata() const {
	+ return _internal_has_authenticationinformationdata()
	+ ? *data_.authenticationinformationdata_
	+ : reinterpret_cast< ::backup::AuthenticationInformationData&>(::backup::_AuthenticationInformationData_default_instance_);
	}
	-inline std::string* PullBackupKeyResponse::release_encryptedbackupkey() {
	- // @@protoc_insertion_point(field_release:backup.PullBackupKeyResponse.encryptedBackupKey)
	- return encryptedbackupkey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline const ::backup::AuthenticationInformationData& RecoverBackupKeyResponse::authenticationinformationdata() const {
	+ // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyResponse.authenticationInformationData)
	+ return _internal_authenticationinformationdata();
	}
	-inline void PullBackupKeyResponse::set_allocated_encryptedbackupkey(std::string* encryptedbackupkey) {
	- if (encryptedbackupkey != nullptr) {
	-
	+inline ::backup::AuthenticationInformationData* RecoverBackupKeyResponse::unsafe_arena_release_authenticationinformationdata() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.RecoverBackupKeyResponse.authenticationInformationData)
	+ if (_internal_has_authenticationinformationdata()) {
	+ clear_has_data();
	+ ::backup::AuthenticationInformationData* temp = data_.authenticationinformationdata_;
	+ data_.authenticationinformationdata_ = nullptr;
	+ return temp;
	} else {
	-
	+ return nullptr;
	}
	- encryptedbackupkey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryptedbackupkey,
	- GetArena());
	- // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyResponse.encryptedBackupKey)
	+}
	+inline void RecoverBackupKeyResponse::unsafe_arena_set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata) {
	+ clear_data();
	+ if (authenticationinformationdata) {
	+ set_has_authenticationinformationdata();
	+ data_.authenticationinformationdata_ = authenticationinformationdata;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.RecoverBackupKeyResponse.authenticationInformationData)
	+}
	+inline ::backup::AuthenticationInformationData* RecoverBackupKeyResponse::_internal_mutable_authenticationinformationdata() {
	+ if (!_internal_has_authenticationinformationdata()) {
	+ clear_data();
	+ set_has_authenticationinformationdata();
	+ data_.authenticationinformationdata_ = CreateMaybeMessage< ::backup::AuthenticationInformationData >(GetArena());
	+ }
	+ return data_.authenticationinformationdata_;
	+}
	+inline ::backup::AuthenticationInformationData* RecoverBackupKeyResponse::mutable_authenticationinformationdata() {
	+ // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyResponse.authenticationInformationData)
	+ return _internal_mutable_authenticationinformationdata();
	}

	-// -------------------------------------------------------------------
	-
	-// PullCompactionRequest
	-
	-// string userId = 1;
	-inline void PullCompactionRequest::clear_userid() {
	- userid_.ClearToEmpty();
	+// string backupID = 3;
	+inline bool RecoverBackupKeyResponse::_internal_has_backupid() const {
	+ return data_case() == kBackupID;
	}
	-inline const std::string& PullCompactionRequest::userid() const {
	- // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.userId)
	- return _internal_userid();
	+inline bool RecoverBackupKeyResponse::has_backupid() const {
	+ return _internal_has_backupid();
	}
	-inline void PullCompactionRequest::set_userid(const std::string& value) {
	- _internal_set_userid(value);
	- // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.userId)
	+inline void RecoverBackupKeyResponse::set_has_backupid() {
	+ _oneof_case_[0] = kBackupID;
	}
	-inline std::string* PullCompactionRequest::mutable_userid() {
	- // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.userId)
	- return _internal_mutable_userid();
	+inline void RecoverBackupKeyResponse::clear_backupid() {
	+ if (_internal_has_backupid()) {
	+ data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_data();
	+ }
	}
	-inline const std::string& PullCompactionRequest::_internal_userid() const {
	- return userid_.Get();
	+inline const std::string& RecoverBackupKeyResponse::backupid() const {
	+ // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyResponse.backupID)
	+ return _internal_backupid();
	}
	-inline void PullCompactionRequest::_internal_set_userid(const std::string& value) {
	-
	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+inline void RecoverBackupKeyResponse::set_backupid(const std::string& value) {
	+ _internal_set_backupid(value);
	+ // @@protoc_insertion_point(field_set:backup.RecoverBackupKeyResponse.backupID)
	}
	-inline void PullCompactionRequest::set_userid(std::string&& value) {
	-
	- userid_.Set(
	+inline std::string* RecoverBackupKeyResponse::mutable_backupid() {
	+ // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyResponse.backupID)
	+ return _internal_mutable_backupid();
	+}
	+inline const std::string& RecoverBackupKeyResponse::_internal_backupid() const {
	+ if (_internal_has_backupid()) {
	+ return data_.backupid_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void RecoverBackupKeyResponse::_internal_set_backupid(const std::string& value) {
	+ if (!_internal_has_backupid()) {
	+ clear_data();
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void RecoverBackupKeyResponse::set_backupid(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.RecoverBackupKeyResponse.backupID)
	+ if (!_internal_has_backupid()) {
	+ clear_data();
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.backupid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionRequest.userId)
	+ // @@protoc_insertion_point(field_set_rvalue:backup.RecoverBackupKeyResponse.backupID)
	}
	-inline void PullCompactionRequest::set_userid(const char* value) {
	+inline void RecoverBackupKeyResponse::set_backupid(const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	-
	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.PullCompactionRequest.userId)
	-}
	-inline void PullCompactionRequest::set_userid(const char* value,
	- size_t size) {
	-
	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	- reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionRequest.userId)
	+ if (!_internal_has_backupid()) {
	+ clear_data();
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.RecoverBackupKeyResponse.backupID)
	}
	-inline std::string* PullCompactionRequest::_internal_mutable_userid() {
	-
	- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+inline void RecoverBackupKeyResponse::set_backupid(const char* value,
	+ size_t size) {
	+ if (!_internal_has_backupid()) {
	+ clear_data();
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.backupid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.RecoverBackupKeyResponse.backupID)
	}
	-inline std::string* PullCompactionRequest::release_userid() {
	- // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.userId)
	- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* RecoverBackupKeyResponse::_internal_mutable_backupid() {
	+ if (!_internal_has_backupid()) {
	+ clear_data();
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return data_.backupid_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline void PullCompactionRequest::set_allocated_userid(std::string* userid) {
	- if (userid != nullptr) {
	-
	+inline std::string* RecoverBackupKeyResponse::release_backupid() {
	+ // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyResponse.backupID)
	+ if (_internal_has_backupid()) {
	+ clear_has_data();
	+ return data_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	} else {
	-
	+ return nullptr;
	}
	- userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
	- GetArena());
	- // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.userId)
	+}
	+inline void RecoverBackupKeyResponse::set_allocated_backupid(std::string* backupid) {
	+ if (has_data()) {
	+ clear_data();
	+ }
	+ if (backupid != nullptr) {
	+ set_has_backupid();
	+ data_.backupid_.UnsafeSetDefault(backupid);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(backupid);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyResponse.backupID)
	}

	-// bytes message = 2;
	-inline void PullCompactionRequest::clear_message() {
	- message_.ClearToEmpty();
	+inline bool RecoverBackupKeyResponse::has_data() const {
	+ return data_case() != DATA_NOT_SET;
	+}
	+inline void RecoverBackupKeyResponse::clear_has_data() {
	+ _oneof_case_[0] = DATA_NOT_SET;
	}
	-inline const std::string& PullCompactionRequest::message() const {
	- // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.message)
	- return _internal_message();
	+inline RecoverBackupKeyResponse::DataCase RecoverBackupKeyResponse::data_case() const {
	+ return RecoverBackupKeyResponse::DataCase(_oneof_case_[0]);
	}
	-inline void PullCompactionRequest::set_message(const std::string& value) {
	- _internal_set_message(value);
	- // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.message)
	+// -------------------------------------------------------------------
	+
	+// PullBackupRequest
	+
	+// .backup.SimpleAuthenticationRequestData authenticationData = 1;
	+inline bool PullBackupRequest::_internal_has_authenticationdata() const {
	+ return this != internal_default_instance() && authenticationdata_ != nullptr;
	}
	-inline std::string* PullCompactionRequest::mutable_message() {
	- // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.message)
	- return _internal_mutable_message();
	+inline bool PullBackupRequest::has_authenticationdata() const {
	+ return _internal_has_authenticationdata();
	}
	-inline const std::string& PullCompactionRequest::_internal_message() const {
	- return message_.Get();
	+inline void PullBackupRequest::clear_authenticationdata() {
	+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
	+ delete authenticationdata_;
	+ }
	+ authenticationdata_ = nullptr;
	}
	-inline void PullCompactionRequest::_internal_set_message(const std::string& value) {
	-
	- message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+inline const ::backup::SimpleAuthenticationRequestData& PullBackupRequest::_internal_authenticationdata() const {
	+ const ::backup::SimpleAuthenticationRequestData* p = authenticationdata_;
	+ return p != nullptr ? *p : reinterpret_cast<const ::backup::SimpleAuthenticationRequestData&>(
	+ ::backup::_SimpleAuthenticationRequestData_default_instance_);
	}
	-inline void PullCompactionRequest::set_message(std::string&& value) {
	-
	- message_.Set(
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionRequest.message)
	+inline const ::backup::SimpleAuthenticationRequestData& PullBackupRequest::authenticationdata() const {
	+ // @@protoc_insertion_point(field_get:backup.PullBackupRequest.authenticationData)
	+ return _internal_authenticationdata();
	}
	-inline void PullCompactionRequest::set_message(const char* value) {
	- GOOGLE_DCHECK(value != nullptr);
	-
	- message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.PullCompactionRequest.message)
	+inline void PullBackupRequest::unsafe_arena_set_allocated_authenticationdata(
	+ ::backup::SimpleAuthenticationRequestData* authenticationdata) {
	+ if (GetArena() == nullptr) {
	+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_);
	+ }
	+ authenticationdata_ = authenticationdata;
	+ if (authenticationdata) {
	+
	+ } else {
	+
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.PullBackupRequest.authenticationData)
	}
	-inline void PullCompactionRequest::set_message(const void* value,
	- size_t size) {
	+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::release_authenticationdata() {

	- message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	- reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionRequest.message)
	+ ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
	+ authenticationdata_ = nullptr;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ return temp;
	}
	-inline std::string* PullCompactionRequest::_internal_mutable_message() {
	+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::unsafe_arena_release_authenticationdata() {
	+ // @@protoc_insertion_point(field_release:backup.PullBackupRequest.authenticationData)

	- return message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
	+ authenticationdata_ = nullptr;
	+ return temp;
	}
	-inline std::string* PullCompactionRequest::release_message() {
	- // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.message)
	- return message_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	-}
	-inline void PullCompactionRequest::set_allocated_message(std::string* message) {
	- if (message != nullptr) {
	+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::_internal_mutable_authenticationdata() {
	+
	+ if (authenticationdata_ == nullptr) {
	+ auto* p = CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(GetArena());
	+ authenticationdata_ = p;
	+ }
	+ return authenticationdata_;
	+}
	+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::mutable_authenticationdata() {
	+ // @@protoc_insertion_point(field_mutable:backup.PullBackupRequest.authenticationData)
	+ return _internal_mutable_authenticationdata();
	+}
	+inline void PullBackupRequest::set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ if (message_arena == nullptr) {
	+ delete authenticationdata_;
	+ }
	+ if (authenticationdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata);
	+ if (message_arena != submessage_arena) {
	+ authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, authenticationdata, submessage_arena);
	+ }

	} else {

	}
	- message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message,
	- GetArena());
	- // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.message)
	+ authenticationdata_ = authenticationdata;
	+ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupRequest.authenticationData)
	}

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

	-// PullCompactionResponse
	+// PullBackupResponse

	// bytes compactionChunk = 1;
	-inline bool PullCompactionResponse::_internal_has_compactionchunk() const {
	+inline bool PullBackupResponse::_internal_has_compactionchunk() const {
	return data_case() == kCompactionChunk;
	}
	-inline bool PullCompactionResponse::has_compactionchunk() const {
	+inline bool PullBackupResponse::has_compactionchunk() const {
	return _internal_has_compactionchunk();
	}
	-inline void PullCompactionResponse::set_has_compactionchunk() {
	+inline void PullBackupResponse::set_has_compactionchunk() {
	_oneof_case_[0] = kCompactionChunk;
	}
	-inline void PullCompactionResponse::clear_compactionchunk() {
	+inline void PullBackupResponse::clear_compactionchunk() {
	if (_internal_has_compactionchunk()) {
	data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	clear_has_data();
	}
	}
	-inline const std::string& PullCompactionResponse::compactionchunk() const {
	- // @@protoc_insertion_point(field_get:backup.PullCompactionResponse.compactionChunk)
	+inline const std::string& PullBackupResponse::compactionchunk() const {
	+ // @@protoc_insertion_point(field_get:backup.PullBackupResponse.compactionChunk)
	return _internal_compactionchunk();
	}
	-inline void PullCompactionResponse::set_compactionchunk(const std::string& value) {
	+inline void PullBackupResponse::set_compactionchunk(const std::string& value) {
	_internal_set_compactionchunk(value);
	- // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.compactionChunk)
	+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.compactionChunk)
	}
	-inline std::string* PullCompactionResponse::mutable_compactionchunk() {
	- // @@protoc_insertion_point(field_mutable:backup.PullCompactionResponse.compactionChunk)
	+inline std::string* PullBackupResponse::mutable_compactionchunk() {
	+ // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.compactionChunk)
	return _internal_mutable_compactionchunk();
	}
	-inline const std::string& PullCompactionResponse::_internal_compactionchunk() const {
	+inline const std::string& PullBackupResponse::_internal_compactionchunk() const {
	if (_internal_has_compactionchunk()) {
	return data_.compactionchunk_.Get();
	}
	return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	}
	-inline void PullCompactionResponse::_internal_set_compactionchunk(const std::string& value) {
	+inline void PullBackupResponse::_internal_set_compactionchunk(const std::string& value) {
	if (!_internal_has_compactionchunk()) {
	clear_data();
	set_has_compactionchunk();
	@@ -1901,8 +4956,8 @@
	}
	data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void PullCompactionResponse::set_compactionchunk(std::string&& value) {
	- // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.compactionChunk)
	+inline void PullBackupResponse::set_compactionchunk(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.compactionChunk)
	if (!_internal_has_compactionchunk()) {
	clear_data();
	set_has_compactionchunk();
	@@ -1910,9 +4965,9 @@
	}
	data_.compactionchunk_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionResponse.compactionChunk)
	+ // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.compactionChunk)
	}
	-inline void PullCompactionResponse::set_compactionchunk(const char* value) {
	+inline void PullBackupResponse::set_compactionchunk(const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	if (!_internal_has_compactionchunk()) {
	clear_data();
	@@ -1921,9 +4976,9 @@
	}
	data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.PullCompactionResponse.compactionChunk)
	+ // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.compactionChunk)
	}
	-inline void PullCompactionResponse::set_compactionchunk(const void* value,
	+inline void PullBackupResponse::set_compactionchunk(const void* value,
	size_t size) {
	if (!_internal_has_compactionchunk()) {
	clear_data();
	@@ -1934,9 +4989,9 @@
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size),
	GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionResponse.compactionChunk)
	+ // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.compactionChunk)
	}
	-inline std::string* PullCompactionResponse::_internal_mutable_compactionchunk() {
	+inline std::string* PullBackupResponse::_internal_mutable_compactionchunk() {
	if (!_internal_has_compactionchunk()) {
	clear_data();
	set_has_compactionchunk();
	@@ -1945,8 +5000,8 @@
	return data_.compactionchunk_.Mutable(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* PullCompactionResponse::release_compactionchunk() {
	- // @@protoc_insertion_point(field_release:backup.PullCompactionResponse.compactionChunk)
	+inline std::string* PullBackupResponse::release_compactionchunk() {
	+ // @@protoc_insertion_point(field_release:backup.PullBackupResponse.compactionChunk)
	if (_internal_has_compactionchunk()) {
	clear_has_data();
	return data_.compactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	@@ -1954,7 +5009,7 @@
	return nullptr;
	}
	}
	-inline void PullCompactionResponse::set_allocated_compactionchunk(std::string* compactionchunk) {
	+inline void PullBackupResponse::set_allocated_compactionchunk(std::string* compactionchunk) {
	if (has_data()) {
	clear_data();
	}
	@@ -1966,44 +5021,44 @@
	arena->Own(compactionchunk);
	}
	}
	- // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionResponse.compactionChunk)
	+ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.compactionChunk)
	}

	// bytes logChunk = 2;
	-inline bool PullCompactionResponse::_internal_has_logchunk() const {
	+inline bool PullBackupResponse::_internal_has_logchunk() const {
	return data_case() == kLogChunk;
	}
	-inline bool PullCompactionResponse::has_logchunk() const {
	+inline bool PullBackupResponse::has_logchunk() const {
	return _internal_has_logchunk();
	}
	-inline void PullCompactionResponse::set_has_logchunk() {
	+inline void PullBackupResponse::set_has_logchunk() {
	_oneof_case_[0] = kLogChunk;
	}
	-inline void PullCompactionResponse::clear_logchunk() {
	+inline void PullBackupResponse::clear_logchunk() {
	if (_internal_has_logchunk()) {
	data_.logchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	clear_has_data();
	}
	}
	-inline const std::string& PullCompactionResponse::logchunk() const {
	- // @@protoc_insertion_point(field_get:backup.PullCompactionResponse.logChunk)
	+inline const std::string& PullBackupResponse::logchunk() const {
	+ // @@protoc_insertion_point(field_get:backup.PullBackupResponse.logChunk)
	return _internal_logchunk();
	}
	-inline void PullCompactionResponse::set_logchunk(const std::string& value) {
	+inline void PullBackupResponse::set_logchunk(const std::string& value) {
	_internal_set_logchunk(value);
	- // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.logChunk)
	+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.logChunk)
	}
	-inline std::string* PullCompactionResponse::mutable_logchunk() {
	- // @@protoc_insertion_point(field_mutable:backup.PullCompactionResponse.logChunk)
	+inline std::string* PullBackupResponse::mutable_logchunk() {
	+ // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.logChunk)
	return _internal_mutable_logchunk();
	}
	-inline const std::string& PullCompactionResponse::_internal_logchunk() const {
	+inline const std::string& PullBackupResponse::_internal_logchunk() const {
	if (_internal_has_logchunk()) {
	return data_.logchunk_.Get();
	}
	return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	}
	-inline void PullCompactionResponse::_internal_set_logchunk(const std::string& value) {
	+inline void PullBackupResponse::_internal_set_logchunk(const std::string& value) {
	if (!_internal_has_logchunk()) {
	clear_data();
	set_has_logchunk();
	@@ -2011,8 +5066,8 @@
	}
	data_.logchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void PullCompactionResponse::set_logchunk(std::string&& value) {
	- // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.logChunk)
	+inline void PullBackupResponse::set_logchunk(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.logChunk)
	if (!_internal_has_logchunk()) {
	clear_data();
	set_has_logchunk();
	@@ -2020,9 +5075,9 @@
	}
	data_.logchunk_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionResponse.logChunk)
	+ // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.logChunk)
	}
	-inline void PullCompactionResponse::set_logchunk(const char* value) {
	+inline void PullBackupResponse::set_logchunk(const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	if (!_internal_has_logchunk()) {
	clear_data();
	@@ -2031,9 +5086,9 @@
	}
	data_.logchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:backup.PullCompactionResponse.logChunk)
	+ // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.logChunk)
	}
	-inline void PullCompactionResponse::set_logchunk(const void* value,
	+inline void PullBackupResponse::set_logchunk(const void* value,
	size_t size) {
	if (!_internal_has_logchunk()) {
	clear_data();
	@@ -2044,9 +5099,9 @@
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size),
	GetArena());
	- // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionResponse.logChunk)
	+ // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.logChunk)
	}
	-inline std::string* PullCompactionResponse::_internal_mutable_logchunk() {
	+inline std::string* PullBackupResponse::_internal_mutable_logchunk() {
	if (!_internal_has_logchunk()) {
	clear_data();
	set_has_logchunk();
	@@ -2055,8 +5110,8 @@
	return data_.logchunk_.Mutable(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* PullCompactionResponse::release_logchunk() {
	- // @@protoc_insertion_point(field_release:backup.PullCompactionResponse.logChunk)
	+inline std::string* PullBackupResponse::release_logchunk() {
	+ // @@protoc_insertion_point(field_release:backup.PullBackupResponse.logChunk)
	if (_internal_has_logchunk()) {
	clear_has_data();
	return data_.logchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	@@ -2064,7 +5119,7 @@
	return nullptr;
	}
	}
	-inline void PullCompactionResponse::set_allocated_logchunk(std::string* logchunk) {
	+inline void PullBackupResponse::set_allocated_logchunk(std::string* logchunk) {
	if (has_data()) {
	clear_data();
	}
	@@ -2076,17 +5131,17 @@
	arena->Own(logchunk);
	}
	}
	- // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionResponse.logChunk)
	+ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.logChunk)
	}

	-inline bool PullCompactionResponse::has_data() const {
	+inline bool PullBackupResponse::has_data() const {
	return data_case() != DATA_NOT_SET;
	}
	-inline void PullCompactionResponse::clear_has_data() {
	+inline void PullBackupResponse::clear_has_data() {
	_oneof_case_[0] = DATA_NOT_SET;
	}
	-inline PullCompactionResponse::DataCase PullCompactionResponse::data_case() const {
	- return PullCompactionResponse::DataCase(_oneof_case_[0]);
	+inline PullBackupResponse::DataCase PullBackupResponse::data_case() const {
	+ return PullBackupResponse::DataCase(_oneof_case_[0]);
	}
	#ifdef __GNUC__
	#pragma GCC diagnostic pop
	@@ -2101,6 +5156,16 @@

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

	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+

	// @@protoc_insertion_point(namespace_scope)

	diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc
	--- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc
	+++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc
	@@ -17,23 +17,84 @@

	PROTOBUF_PRAGMA_INIT_SEG
	namespace backup {
	-constexpr ResetKeyRequest::ResetKeyRequest(
	+constexpr FullAuthenticationRequestData::FullAuthenticationRequestData(
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	: userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	, _oneof_case_{}{}
	-struct ResetKeyRequestDefaultTypeInternal {
	- constexpr ResetKeyRequestDefaultTypeInternal()
	+struct FullAuthenticationRequestDataDefaultTypeInternal {
	+ constexpr FullAuthenticationRequestDataDefaultTypeInternal()
	: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	- ~ResetKeyRequestDefaultTypeInternal() {}
	+ ~FullAuthenticationRequestDataDefaultTypeInternal() {}
	union {
	- ResetKeyRequest _instance;
	+ FullAuthenticationRequestData _instance;
	};
	};
	-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResetKeyRequestDefaultTypeInternal _ResetKeyRequest_default_instance_;
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FullAuthenticationRequestDataDefaultTypeInternal _FullAuthenticationRequestData_default_instance_;
	+constexpr FullAuthenticationResponseData::FullAuthenticationResponseData(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : _oneof_case_{}{}
	+struct FullAuthenticationResponseDataDefaultTypeInternal {
	+ constexpr FullAuthenticationResponseDataDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~FullAuthenticationResponseDataDefaultTypeInternal() {}
	+ union {
	+ FullAuthenticationResponseData _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FullAuthenticationResponseDataDefaultTypeInternal _FullAuthenticationResponseData_default_instance_;
	+constexpr SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : backupid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	+struct SimpleAuthenticationRequestDataDefaultTypeInternal {
	+ constexpr SimpleAuthenticationRequestDataDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~SimpleAuthenticationRequestDataDefaultTypeInternal() {}
	+ union {
	+ SimpleAuthenticationRequestData _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleAuthenticationRequestDataDefaultTypeInternal _SimpleAuthenticationRequestData_default_instance_;
	+constexpr AuthenticationInformationData::AuthenticationInformationData(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : _oneof_case_{}{}
	+struct AuthenticationInformationDataDefaultTypeInternal {
	+ constexpr AuthenticationInformationDataDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~AuthenticationInformationDataDefaultTypeInternal() {}
	+ union {
	+ AuthenticationInformationData _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AuthenticationInformationDataDefaultTypeInternal _AuthenticationInformationData_default_instance_;
	+constexpr CreateNewBackupRequest::CreateNewBackupRequest(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : _oneof_case_{}{}
	+struct CreateNewBackupRequestDefaultTypeInternal {
	+ constexpr CreateNewBackupRequestDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~CreateNewBackupRequestDefaultTypeInternal() {}
	+ union {
	+ CreateNewBackupRequest _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CreateNewBackupRequestDefaultTypeInternal _CreateNewBackupRequest_default_instance_;
	+constexpr CreateNewBackupResponse::CreateNewBackupResponse(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : _oneof_case_{}{}
	+struct CreateNewBackupResponseDefaultTypeInternal {
	+ constexpr CreateNewBackupResponseDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~CreateNewBackupResponseDefaultTypeInternal() {}
	+ union {
	+ CreateNewBackupResponse _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CreateNewBackupResponseDefaultTypeInternal _CreateNewBackupResponse_default_instance_;
	constexpr SendLogRequest::SendLogRequest(
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	- , data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	+ : logdata_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , authenticationdata_(nullptr){}
	struct SendLogRequestDefaultTypeInternal {
	constexpr SendLogRequestDefaultTypeInternal()
	: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	@@ -43,153 +104,240 @@
	};
	};
	PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SendLogRequestDefaultTypeInternal _SendLogRequest_default_instance_;
	-constexpr PullBackupKeyRequest::PullBackupKeyRequest(
	+constexpr RecoverBackupKeyRequest::RecoverBackupKeyRequest(
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	- , pakekey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	-struct PullBackupKeyRequestDefaultTypeInternal {
	- constexpr PullBackupKeyRequestDefaultTypeInternal()
	+ : authenticationdata_(nullptr){}
	+struct RecoverBackupKeyRequestDefaultTypeInternal {
	+ constexpr RecoverBackupKeyRequestDefaultTypeInternal()
	: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	- ~PullBackupKeyRequestDefaultTypeInternal() {}
	+ ~RecoverBackupKeyRequestDefaultTypeInternal() {}
	union {
	- PullBackupKeyRequest _instance;
	+ RecoverBackupKeyRequest _instance;
	};
	};
	-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupKeyRequestDefaultTypeInternal _PullBackupKeyRequest_default_instance_;
	-constexpr PullBackupKeyResponse::PullBackupKeyResponse(
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecoverBackupKeyRequestDefaultTypeInternal _RecoverBackupKeyRequest_default_instance_;
	+constexpr RecoverBackupKeyResponse::RecoverBackupKeyResponse(
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	- : encryptedbackupkey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	-struct PullBackupKeyResponseDefaultTypeInternal {
	- constexpr PullBackupKeyResponseDefaultTypeInternal()
	+ : _oneof_case_{}{}
	+struct RecoverBackupKeyResponseDefaultTypeInternal {
	+ constexpr RecoverBackupKeyResponseDefaultTypeInternal()
	: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	- ~PullBackupKeyResponseDefaultTypeInternal() {}
	+ ~RecoverBackupKeyResponseDefaultTypeInternal() {}
	union {
	- PullBackupKeyResponse _instance;
	+ RecoverBackupKeyResponse _instance;
	};
	};
	-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupKeyResponseDefaultTypeInternal _PullBackupKeyResponse_default_instance_;
	-constexpr PullCompactionRequest::PullCompactionRequest(
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecoverBackupKeyResponseDefaultTypeInternal _RecoverBackupKeyResponse_default_instance_;
	+constexpr PullBackupRequest::PullBackupRequest(
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	- , message_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	-struct PullCompactionRequestDefaultTypeInternal {
	- constexpr PullCompactionRequestDefaultTypeInternal()
	+ : authenticationdata_(nullptr){}
	+struct PullBackupRequestDefaultTypeInternal {
	+ constexpr PullBackupRequestDefaultTypeInternal()
	: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	- ~PullCompactionRequestDefaultTypeInternal() {}
	+ ~PullBackupRequestDefaultTypeInternal() {}
	union {
	- PullCompactionRequest _instance;
	+ PullBackupRequest _instance;
	};
	};
	-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullCompactionRequestDefaultTypeInternal _PullCompactionRequest_default_instance_;
	-constexpr PullCompactionResponse::PullCompactionResponse(
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupRequestDefaultTypeInternal _PullBackupRequest_default_instance_;
	+constexpr PullBackupResponse::PullBackupResponse(
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	: _oneof_case_{}{}
	-struct PullCompactionResponseDefaultTypeInternal {
	- constexpr PullCompactionResponseDefaultTypeInternal()
	+struct PullBackupResponseDefaultTypeInternal {
	+ constexpr PullBackupResponseDefaultTypeInternal()
	: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	- ~PullCompactionResponseDefaultTypeInternal() {}
	+ ~PullBackupResponseDefaultTypeInternal() {}
	union {
	- PullCompactionResponse _instance;
	+ PullBackupResponse _instance;
	};
	};
	-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullCompactionResponseDefaultTypeInternal _PullCompactionResponse_default_instance_;
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupResponseDefaultTypeInternal _PullBackupResponse_default_instance_;
	} // namespace backup
	-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_backup_2eproto[6];
	+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_backup_2eproto[11];
	static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_backup_2eproto = nullptr;
	static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_backup_2eproto = nullptr;

	const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_backup_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
	~0u, // no _has_bits_
	- PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, _internal_metadata_),
	+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, _internal_metadata_),
	~0u, // no _extensions_
	- PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, _oneof_case_[0]),
	+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, _oneof_case_[0]),
	~0u, // no _weak_field_map_
	- PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, userid_),
	::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	- PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, data_),
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, userid_),
	+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, requestBytes_),
	~0u, // no _has_bits_
	- PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, _internal_metadata_),
	+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationResponseData, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationResponseData, _oneof_case_[0]),
	+ ~0u, // no _weak_field_map_
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationResponseData, responseData_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, _internal_metadata_),
	~0u, // no _extensions_
	~0u, // no _oneof_case_
	~0u, // no _weak_field_map_
	- PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, userid_),
	- PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, data_),
	+ PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, backupid_),
	+ PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, userid_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::backup::AuthenticationInformationData, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::backup::AuthenticationInformationData, _oneof_case_[0]),
	+ ~0u, // no _weak_field_map_
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::backup::AuthenticationInformationData, data_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, _oneof_case_[0]),
	+ ~0u, // no _weak_field_map_
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, data_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, _oneof_case_[0]),
	+ ~0u, // no _weak_field_map_
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, data_),
	~0u, // no _has_bits_
	- PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, _internal_metadata_),
	+ PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, _internal_metadata_),
	~0u, // no _extensions_
	~0u, // no _oneof_case_
	~0u, // no _weak_field_map_
	- PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, userid_),
	- PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, pakekey_),
	+ PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, authenticationdata_),
	+ PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, logdata_),
	~0u, // no _has_bits_
	- PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyResponse, _internal_metadata_),
	+ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyRequest, _internal_metadata_),
	~0u, // no _extensions_
	~0u, // no _oneof_case_
	~0u, // no _weak_field_map_
	- PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyResponse, encryptedbackupkey_),
	+ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyRequest, authenticationdata_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyResponse, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyResponse, _oneof_case_[0]),
	+ ~0u, // no _weak_field_map_
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyResponse, data_),
	~0u, // no _has_bits_
	- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, _internal_metadata_),
	+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupRequest, _internal_metadata_),
	~0u, // no _extensions_
	~0u, // no _oneof_case_
	~0u, // no _weak_field_map_
	- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, userid_),
	- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, message_),
	+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupRequest, authenticationdata_),
	~0u, // no _has_bits_
	- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, _internal_metadata_),
	+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, _internal_metadata_),
	~0u, // no _extensions_
	- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, _oneof_case_[0]),
	+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, _oneof_case_[0]),
	~0u, // no _weak_field_map_
	::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, data_),
	+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, data_),
	};
	static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
	- { 0, -1, sizeof(::backup::ResetKeyRequest)},
	- { 9, -1, sizeof(::backup::SendLogRequest)},
	- { 16, -1, sizeof(::backup::PullBackupKeyRequest)},
	- { 23, -1, sizeof(::backup::PullBackupKeyResponse)},
	- { 29, -1, sizeof(::backup::PullCompactionRequest)},
	- { 36, -1, sizeof(::backup::PullCompactionResponse)},
	+ { 0, -1, sizeof(::backup::FullAuthenticationRequestData)},
	+ { 13, -1, sizeof(::backup::FullAuthenticationResponseData)},
	+ { 24, -1, sizeof(::backup::SimpleAuthenticationRequestData)},
	+ { 31, -1, sizeof(::backup::AuthenticationInformationData)},
	+ { 39, -1, sizeof(::backup::CreateNewBackupRequest)},
	+ { 48, -1, sizeof(::backup::CreateNewBackupResponse)},
	+ { 56, -1, sizeof(::backup::SendLogRequest)},
	+ { 63, -1, sizeof(::backup::RecoverBackupKeyRequest)},
	+ { 69, -1, sizeof(::backup::RecoverBackupKeyResponse)},
	+ { 78, -1, sizeof(::backup::PullBackupRequest)},
	+ { 84, -1, sizeof(::backup::PullBackupResponse)},
	};

	static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
	- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_ResetKeyRequest_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_FullAuthenticationRequestData_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_FullAuthenticationResponseData_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_SimpleAuthenticationRequestData_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_AuthenticationInformationData_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_CreateNewBackupRequest_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_CreateNewBackupResponse_default_instance_),
	reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_SendLogRequest_default_instance_),
	- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupKeyRequest_default_instance_),
	- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupKeyResponse_default_instance_),
	- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullCompactionRequest_default_instance_),
	- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullCompactionResponse_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_RecoverBackupKeyRequest_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_RecoverBackupKeyResponse_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupRequest_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupResponse_default_instance_),
	};

	const char descriptor_table_protodef_backup_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
	"\n\014backup.proto\022\006backup\032\033google/protobuf/"
	- "empty.proto\"V\n\017ResetKeyRequest\022\016\n\006userId"
	- "\030\001 \001(\t\022\020\n\006newKey\030\002 \001(\014H\000\022\031\n\017compactionCh"
	- "unk\030\003 \001(\014H\000B\006\n\004data\".\n\016SendLogRequest\022\016\n"
	- "\006userId\030\001 \001(\t\022\014\n\004data\030\002 \001(\014\"7\n\024PullBacku"
	- "pKeyRequest\022\016\n\006userId\030\001 \001(\t\022\017\n\007pakeKey\030\002"
	- " \001(\014\"3\n\025PullBackupKeyResponse\022\032\n\022encrypt"
	- "edBackupKey\030\001 \001(\014\"8\n\025PullCompactionReque"
	- "st\022\016\n\006userId\030\001 \001(\t\022\017\n\007message\030\002 \001(\014\"O\n\026P"
	- "ullCompactionResponse\022\031\n\017compactionChunk"
	- "\030\001 \001(\014H\000\022\022\n\010logChunk\030\002 \001(\014H\000B\006\n\004data2\262\002\n"
	- "\rBackupService\022\?\n\010ResetKey\022\027.backup.Rese"
	- "tKeyRequest\032\026.google.protobuf.Empty\"\000(\001\022"
	- ";\n\007SendLog\022\026.backup.SendLogRequest\032\026.goo"
	- "gle.protobuf.Empty\"\000\022N\n\rPullBackupKey\022\034."
	- "backup.PullBackupKeyRequest\032\035.backup.Pul"
	- "lBackupKeyResponse\"\000\022S\n\016PullCompaction\022\035"
	- ".backup.PullCompactionRequest\032\036.backup.P"
	- "ullCompactionResponse\"\0000\001b\006proto3"
	+ "empty.proto\"\223\002\n\035FullAuthenticationReques"
	+ "tData\022!\n\027pakeRegistrationRequest\030\001 \001(\014H\000"
	+ "\022 \n\026pakeRegistrationUpload\030\002 \001(\014H\000\022\037\n\025pa"
	+ "keCredentialRequest\030\003 \001(\014H\000\022$\n\032pakeCrede"
	+ "ntialFinalization\030\004 \001(\014H\000\022\037\n\025pakeChallen"
	+ "geResponse\030\005 \001(\014H\000\022%\n\033walletAuthenticati"
	+ "onRequest\030\006 \001(\014H\000\022\016\n\006userID\030\007 \001(\tB\016\n\014req"
	+ "uestBytes\"\341\001\n\036FullAuthenticationResponse"
	+ "Data\022\"\n\030pakeRegistrationResponse\030\001 \001(\014H\000"
	+ "\022!\n\027pakeRegistrationSuccess\030\002 \001(\010H\000\022 \n\026p"
	+ "akeCredentialResponse\030\003 \001(\014H\000\022\036\n\024pakeCha"
	+ "llengeMessage\030\004 \001(\014H\000\022&\n\034walletAuthentic"
	+ "ationResponse\030\005 \001(\014H\000B\016\n\014responseData\"C\n"
	+ "\037SimpleAuthenticationRequestData\022\020\n\010back"
	+ "upID\030\001 \001(\t\022\016\n\006userID\030\002 \001(\t\"N\n\035Authentica"
	+ "tionInformationData\022\017\n\005nonce\030\001 \001(\014H\000\022\024\n\n"
	+ "rawMessage\030\002 \001(\014H\000B\006\n\004data\"\332\001\n\026CreateNew"
	+ "BackupRequest\022J\n\031authenticationRequestDa"
	+ "ta\030\001 \001(\0132%.backup.FullAuthenticationRequ"
	+ "estDataH\000\022N\n\035authenticationInformationDa"
	+ "ta\030\002 \001(\0132%.backup.AuthenticationInformat"
	+ "ionDataH\000\022\034\n\022newCompactionChunk\030\003 \001(\014H\000B"
	+ "\006\n\004data\"\203\001\n\027CreateNewBackupResponse\022L\n\032a"
	+ "uthenticationResponseData\030\001 \001(\0132&.backup"
	+ ".FullAuthenticationResponseDataH\000\022\022\n\010bac"
	+ "kupID\030\002 \001(\tH\000B\006\n\004data\"f\n\016SendLogRequest\022"
	+ "C\n\022authenticationData\030\001 \001(\0132\'.backup.Sim"
	+ "pleAuthenticationRequestData\022\017\n\007logData\030"
	+ "\002 \001(\014\"\\\n\027RecoverBackupKeyRequest\022A\n\022auth"
	+ "enticationData\030\001 \001(\0132%.backup.FullAuthen"
	+ "ticationRequestData\"\324\001\n\030RecoverBackupKey"
	+ "Response\022L\n\032authenticationResponseData\030\001"
	+ " \001(\0132&.backup.FullAuthenticationResponse"
	+ "DataH\000\022N\n\035authenticationInformationData\030"
	+ "\002 \001(\0132%.backup.AuthenticationInformation"
	+ "DataH\000\022\022\n\010backupID\030\003 \001(\tH\000B\006\n\004data\"X\n\021Pu"
	+ "llBackupRequest\022C\n\022authenticationData\030\001 "
	+ "\001(\0132\'.backup.SimpleAuthenticationRequest"
	+ "Data\"K\n\022PullBackupResponse\022\031\n\017compaction"
	+ "Chunk\030\001 \001(\014H\000\022\022\n\010logChunk\030\002 \001(\014H\000B\006\n\004dat"
	+ "a2\320\002\n\rBackupService\022X\n\017CreateNewBackup\022\036"
	+ ".backup.CreateNewBackupRequest\032\037.backup."
	+ "CreateNewBackupResponse\"\000(\0010\001\022=\n\007SendLog"
	+ "\022\026.backup.SendLogRequest\032\026.google.protob"
	+ "uf.Empty\"\000(\001\022[\n\020RecoverBackupKey\022\037.backu"
	+ "p.RecoverBackupKeyRequest\032 .backup.Recov"
	+ "erBackupKeyResponse\"\000(\0010\001\022I\n\nPullBackup\022"
	+ "\031.backup.PullBackupRequest\032\032.backup.Pull"
	+ "BackupResponse\"\000(\0010\001b\006proto3"
	;
	static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_backup_2eproto_deps[1] = {
	&::descriptor_table_google_2fprotobuf_2fempty_2eproto,
	};
	static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_backup_2eproto_once;
	const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_backup_2eproto = {
	- false, false, 753, descriptor_table_protodef_backup_2eproto, "backup.proto",
	- &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 6,
	+ false, false, 1988, descriptor_table_protodef_backup_2eproto, "backup.proto",
	+ &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 11,
	schemas, file_default_instances, TableStruct_backup_2eproto::offsets,
	file_level_metadata_backup_2eproto, file_level_enum_descriptors_backup_2eproto, file_level_service_descriptors_backup_2eproto,
	};
	@@ -199,85 +347,1731 @@
	return descriptor_table_backup_2eproto.file_level_metadata[index];
	}

	-// Force running AddDescriptors() at dynamic initialization time.
	-PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_backup_2eproto(&descriptor_table_backup_2eproto);
	-namespace backup {
	+// Force running AddDescriptors() at dynamic initialization time.
	+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_backup_2eproto(&descriptor_table_backup_2eproto);
	+namespace backup {
	+
	+// ===================================================================
	+
	+class FullAuthenticationRequestData::_Internal {
	+ public:
	+};
	+
	+FullAuthenticationRequestData::FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:backup.FullAuthenticationRequestData)
	+}
	+FullAuthenticationRequestData::FullAuthenticationRequestData(const FullAuthenticationRequestData& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_userid().empty()) {
	+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
	+ GetArena());
	+ }
	+ clear_has_requestBytes();
	+ switch (from.requestBytes_case()) {
	+ case kPakeRegistrationRequest: {
	+ _internal_set_pakeregistrationrequest(from._internal_pakeregistrationrequest());
	+ break;
	+ }
	+ case kPakeRegistrationUpload: {
	+ _internal_set_pakeregistrationupload(from._internal_pakeregistrationupload());
	+ break;
	+ }
	+ case kPakeCredentialRequest: {
	+ _internal_set_pakecredentialrequest(from._internal_pakecredentialrequest());
	+ break;
	+ }
	+ case kPakeCredentialFinalization: {
	+ _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
	+ break;
	+ }
	+ case kPakeChallengeResponse: {
	+ _internal_set_pakechallengeresponse(from._internal_pakechallengeresponse());
	+ break;
	+ }
	+ case kWalletAuthenticationRequest: {
	+ _internal_set_walletauthenticationrequest(from._internal_walletauthenticationrequest());
	+ break;
	+ }
	+ case REQUESTBYTES_NOT_SET: {
	+ break;
	+ }
	+ }
	+ // @@protoc_insertion_point(copy_constructor:backup.FullAuthenticationRequestData)
	+}
	+
	+void FullAuthenticationRequestData::SharedCtor() {
	+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+clear_has_requestBytes();
	+}
	+
	+FullAuthenticationRequestData::~FullAuthenticationRequestData() {
	+ // @@protoc_insertion_point(destructor:backup.FullAuthenticationRequestData)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void FullAuthenticationRequestData::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (has_requestBytes()) {
	+ clear_requestBytes();
	+ }
	+}
	+
	+void FullAuthenticationRequestData::ArenaDtor(void* object) {
	+ FullAuthenticationRequestData* _this = reinterpret_cast< FullAuthenticationRequestData* >(object);
	+ (void)_this;
	+}
	+void FullAuthenticationRequestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void FullAuthenticationRequestData::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void FullAuthenticationRequestData::clear_requestBytes() {
	+// @@protoc_insertion_point(one_of_clear_start:backup.FullAuthenticationRequestData)
	+ switch (requestBytes_case()) {
	+ case kPakeRegistrationRequest: {
	+ requestBytes_.pakeregistrationrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kPakeRegistrationUpload: {
	+ requestBytes_.pakeregistrationupload_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kPakeCredentialRequest: {
	+ requestBytes_.pakecredentialrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kPakeCredentialFinalization: {
	+ requestBytes_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kPakeChallengeResponse: {
	+ requestBytes_.pakechallengeresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kWalletAuthenticationRequest: {
	+ requestBytes_.walletauthenticationrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case REQUESTBYTES_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = REQUESTBYTES_NOT_SET;
	+}
	+
	+
	+void FullAuthenticationRequestData::Clear() {
	+// @@protoc_insertion_point(message_clear_start:backup.FullAuthenticationRequestData)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ userid_.ClearToEmpty();
	+ clear_requestBytes();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* FullAuthenticationRequestData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	+ while (!ctx->Done(&ptr)) {
	+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	+ CHK_(ptr);
	+ switch (tag >> 3) {
	+ // bytes pakeRegistrationRequest = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ auto str = _internal_mutable_pakeregistrationrequest();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes pakeRegistrationUpload = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_pakeregistrationupload();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes pakeCredentialRequest = 3;
	+ case 3:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ auto str = _internal_mutable_pakecredentialrequest();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes pakeCredentialFinalization = 4;
	+ case 4:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
	+ auto str = _internal_mutable_pakecredentialfinalization();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes pakeChallengeResponse = 5;
	+ case 5:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
	+ auto str = _internal_mutable_pakechallengeresponse();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes walletAuthenticationRequest = 6;
	+ case 6:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
	+ auto str = _internal_mutable_walletauthenticationrequest();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string userID = 7;
	+ case 7:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
	+ auto str = _internal_mutable_userid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.FullAuthenticationRequestData.userID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ default: {
	+ handle_unusual:
	+ if ((tag & 7) == 4 \|\| tag == 0) {
	+ ctx->SetLastTag(tag);
	+ goto success;
	+ }
	+ ptr = UnknownFieldParse(tag,
	+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
	+ ptr, ctx);
	+ CHK_(ptr != nullptr);
	+ continue;
	+ }
	+ } // switch
	+ } // while
	+success:
	+ return ptr;
	+failure:
	+ ptr = nullptr;
	+ goto success;
	+#undef CHK_
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::uint8* FullAuthenticationRequestData::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:backup.FullAuthenticationRequestData)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // bytes pakeRegistrationRequest = 1;
	+ if (_internal_has_pakeregistrationrequest()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 1, this->_internal_pakeregistrationrequest(), target);
	+ }
	+
	+ // bytes pakeRegistrationUpload = 2;
	+ if (_internal_has_pakeregistrationupload()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 2, this->_internal_pakeregistrationupload(), target);
	+ }
	+
	+ // bytes pakeCredentialRequest = 3;
	+ if (_internal_has_pakecredentialrequest()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 3, this->_internal_pakecredentialrequest(), target);
	+ }
	+
	+ // bytes pakeCredentialFinalization = 4;
	+ if (_internal_has_pakecredentialfinalization()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 4, this->_internal_pakecredentialfinalization(), target);
	+ }
	+
	+ // bytes pakeChallengeResponse = 5;
	+ if (_internal_has_pakechallengeresponse()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 5, this->_internal_pakechallengeresponse(), target);
	+ }
	+
	+ // bytes walletAuthenticationRequest = 6;
	+ if (_internal_has_walletauthenticationrequest()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 6, this->_internal_walletauthenticationrequest(), target);
	+ }
	+
	+ // string userID = 7;
	+ if (this->userid().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "backup.FullAuthenticationRequestData.userID");
	+ target = stream->WriteStringMaybeAliased(
	+ 7, this->_internal_userid(), target);
	+ }
	+
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	+ }
	+ // @@protoc_insertion_point(serialize_to_array_end:backup.FullAuthenticationRequestData)
	+ return target;
	+}
	+
	+size_t FullAuthenticationRequestData::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:backup.FullAuthenticationRequestData)
	+ size_t total_size = 0;
	+
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ // string userID = 7;
	+ if (this->userid().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_userid());
	+ }
	+
	+ switch (requestBytes_case()) {
	+ // bytes pakeRegistrationRequest = 1;
	+ case kPakeRegistrationRequest: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakeregistrationrequest());
	+ break;
	+ }
	+ // bytes pakeRegistrationUpload = 2;
	+ case kPakeRegistrationUpload: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakeregistrationupload());
	+ break;
	+ }
	+ // bytes pakeCredentialRequest = 3;
	+ case kPakeCredentialRequest: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakecredentialrequest());
	+ break;
	+ }
	+ // bytes pakeCredentialFinalization = 4;
	+ case kPakeCredentialFinalization: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakecredentialfinalization());
	+ break;
	+ }
	+ // bytes pakeChallengeResponse = 5;
	+ case kPakeChallengeResponse: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakechallengeresponse());
	+ break;
	+ }
	+ // bytes walletAuthenticationRequest = 6;
	+ case kWalletAuthenticationRequest: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_walletauthenticationrequest());
	+ break;
	+ }
	+ case REQUESTBYTES_NOT_SET: {
	+ break;
	+ }
	+ }
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
	+ _internal_metadata_, total_size, &_cached_size_);
	+ }
	+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
	+ SetCachedSize(cached_size);
	+ return total_size;
	+}
	+
	+void FullAuthenticationRequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:backup.FullAuthenticationRequestData)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const FullAuthenticationRequestData* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<FullAuthenticationRequestData>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.FullAuthenticationRequestData)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.FullAuthenticationRequestData)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void FullAuthenticationRequestData::MergeFrom(const FullAuthenticationRequestData& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:backup.FullAuthenticationRequestData)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ if (from.userid().size() > 0) {
	+ _internal_set_userid(from._internal_userid());
	+ }
	+ switch (from.requestBytes_case()) {
	+ case kPakeRegistrationRequest: {
	+ _internal_set_pakeregistrationrequest(from._internal_pakeregistrationrequest());
	+ break;
	+ }
	+ case kPakeRegistrationUpload: {
	+ _internal_set_pakeregistrationupload(from._internal_pakeregistrationupload());
	+ break;
	+ }
	+ case kPakeCredentialRequest: {
	+ _internal_set_pakecredentialrequest(from._internal_pakecredentialrequest());
	+ break;
	+ }
	+ case kPakeCredentialFinalization: {
	+ _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
	+ break;
	+ }
	+ case kPakeChallengeResponse: {
	+ _internal_set_pakechallengeresponse(from._internal_pakechallengeresponse());
	+ break;
	+ }
	+ case kWalletAuthenticationRequest: {
	+ _internal_set_walletauthenticationrequest(from._internal_walletauthenticationrequest());
	+ break;
	+ }
	+ case REQUESTBYTES_NOT_SET: {
	+ break;
	+ }
	+ }
	+}
	+
	+void FullAuthenticationRequestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:backup.FullAuthenticationRequestData)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void FullAuthenticationRequestData::CopyFrom(const FullAuthenticationRequestData& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:backup.FullAuthenticationRequestData)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool FullAuthenticationRequestData::IsInitialized() const {
	+ return true;
	+}
	+
	+void FullAuthenticationRequestData::InternalSwap(FullAuthenticationRequestData* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ swap(requestBytes_, other->requestBytes_);
	+ swap(_oneof_case_[0], other->_oneof_case_[0]);
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata FullAuthenticationRequestData::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class FullAuthenticationResponseData::_Internal {
	+ public:
	+};
	+
	+FullAuthenticationResponseData::FullAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:backup.FullAuthenticationResponseData)
	+}
	+FullAuthenticationResponseData::FullAuthenticationResponseData(const FullAuthenticationResponseData& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ clear_has_responseData();
	+ switch (from.responseData_case()) {
	+ case kPakeRegistrationResponse: {
	+ _internal_set_pakeregistrationresponse(from._internal_pakeregistrationresponse());
	+ break;
	+ }
	+ case kPakeRegistrationSuccess: {
	+ _internal_set_pakeregistrationsuccess(from._internal_pakeregistrationsuccess());
	+ break;
	+ }
	+ case kPakeCredentialResponse: {
	+ _internal_set_pakecredentialresponse(from._internal_pakecredentialresponse());
	+ break;
	+ }
	+ case kPakeChallengeMessage: {
	+ _internal_set_pakechallengemessage(from._internal_pakechallengemessage());
	+ break;
	+ }
	+ case kWalletAuthenticationResponse: {
	+ _internal_set_walletauthenticationresponse(from._internal_walletauthenticationresponse());
	+ break;
	+ }
	+ case RESPONSEDATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ // @@protoc_insertion_point(copy_constructor:backup.FullAuthenticationResponseData)
	+}
	+
	+void FullAuthenticationResponseData::SharedCtor() {
	+clear_has_responseData();
	+}
	+
	+FullAuthenticationResponseData::~FullAuthenticationResponseData() {
	+ // @@protoc_insertion_point(destructor:backup.FullAuthenticationResponseData)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void FullAuthenticationResponseData::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ if (has_responseData()) {
	+ clear_responseData();
	+ }
	+}
	+
	+void FullAuthenticationResponseData::ArenaDtor(void* object) {
	+ FullAuthenticationResponseData* _this = reinterpret_cast< FullAuthenticationResponseData* >(object);
	+ (void)_this;
	+}
	+void FullAuthenticationResponseData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void FullAuthenticationResponseData::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void FullAuthenticationResponseData::clear_responseData() {
	+// @@protoc_insertion_point(one_of_clear_start:backup.FullAuthenticationResponseData)
	+ switch (responseData_case()) {
	+ case kPakeRegistrationResponse: {
	+ responseData_.pakeregistrationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kPakeRegistrationSuccess: {
	+ // No need to clear
	+ break;
	+ }
	+ case kPakeCredentialResponse: {
	+ responseData_.pakecredentialresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kPakeChallengeMessage: {
	+ responseData_.pakechallengemessage_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kWalletAuthenticationResponse: {
	+ responseData_.walletauthenticationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case RESPONSEDATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = RESPONSEDATA_NOT_SET;
	+}
	+
	+
	+void FullAuthenticationResponseData::Clear() {
	+// @@protoc_insertion_point(message_clear_start:backup.FullAuthenticationResponseData)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ clear_responseData();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* FullAuthenticationResponseData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	+ while (!ctx->Done(&ptr)) {
	+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	+ CHK_(ptr);
	+ switch (tag >> 3) {
	+ // bytes pakeRegistrationResponse = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ auto str = _internal_mutable_pakeregistrationresponse();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bool pakeRegistrationSuccess = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
	+ _internal_set_pakeregistrationsuccess(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes pakeCredentialResponse = 3;
	+ case 3:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ auto str = _internal_mutable_pakecredentialresponse();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes pakeChallengeMessage = 4;
	+ case 4:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
	+ auto str = _internal_mutable_pakechallengemessage();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes walletAuthenticationResponse = 5;
	+ case 5:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
	+ auto str = _internal_mutable_walletauthenticationresponse();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ default: {
	+ handle_unusual:
	+ if ((tag & 7) == 4 \|\| tag == 0) {
	+ ctx->SetLastTag(tag);
	+ goto success;
	+ }
	+ ptr = UnknownFieldParse(tag,
	+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
	+ ptr, ctx);
	+ CHK_(ptr != nullptr);
	+ continue;
	+ }
	+ } // switch
	+ } // while
	+success:
	+ return ptr;
	+failure:
	+ ptr = nullptr;
	+ goto success;
	+#undef CHK_
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::uint8* FullAuthenticationResponseData::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:backup.FullAuthenticationResponseData)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // bytes pakeRegistrationResponse = 1;
	+ if (_internal_has_pakeregistrationresponse()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 1, this->_internal_pakeregistrationresponse(), target);
	+ }
	+
	+ // bool pakeRegistrationSuccess = 2;
	+ if (_internal_has_pakeregistrationsuccess()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_pakeregistrationsuccess(), target);
	+ }
	+
	+ // bytes pakeCredentialResponse = 3;
	+ if (_internal_has_pakecredentialresponse()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 3, this->_internal_pakecredentialresponse(), target);
	+ }
	+
	+ // bytes pakeChallengeMessage = 4;
	+ if (_internal_has_pakechallengemessage()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 4, this->_internal_pakechallengemessage(), target);
	+ }
	+
	+ // bytes walletAuthenticationResponse = 5;
	+ if (_internal_has_walletauthenticationresponse()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 5, this->_internal_walletauthenticationresponse(), target);
	+ }
	+
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	+ }
	+ // @@protoc_insertion_point(serialize_to_array_end:backup.FullAuthenticationResponseData)
	+ return target;
	+}
	+
	+size_t FullAuthenticationResponseData::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:backup.FullAuthenticationResponseData)
	+ size_t total_size = 0;
	+
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ switch (responseData_case()) {
	+ // bytes pakeRegistrationResponse = 1;
	+ case kPakeRegistrationResponse: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakeregistrationresponse());
	+ break;
	+ }
	+ // bool pakeRegistrationSuccess = 2;
	+ case kPakeRegistrationSuccess: {
	+ total_size += 1 + 1;
	+ break;
	+ }
	+ // bytes pakeCredentialResponse = 3;
	+ case kPakeCredentialResponse: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakecredentialresponse());
	+ break;
	+ }
	+ // bytes pakeChallengeMessage = 4;
	+ case kPakeChallengeMessage: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakechallengemessage());
	+ break;
	+ }
	+ // bytes walletAuthenticationResponse = 5;
	+ case kWalletAuthenticationResponse: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_walletauthenticationresponse());
	+ break;
	+ }
	+ case RESPONSEDATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
	+ _internal_metadata_, total_size, &_cached_size_);
	+ }
	+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
	+ SetCachedSize(cached_size);
	+ return total_size;
	+}
	+
	+void FullAuthenticationResponseData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:backup.FullAuthenticationResponseData)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const FullAuthenticationResponseData* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<FullAuthenticationResponseData>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.FullAuthenticationResponseData)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.FullAuthenticationResponseData)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void FullAuthenticationResponseData::MergeFrom(const FullAuthenticationResponseData& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:backup.FullAuthenticationResponseData)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ switch (from.responseData_case()) {
	+ case kPakeRegistrationResponse: {
	+ _internal_set_pakeregistrationresponse(from._internal_pakeregistrationresponse());
	+ break;
	+ }
	+ case kPakeRegistrationSuccess: {
	+ _internal_set_pakeregistrationsuccess(from._internal_pakeregistrationsuccess());
	+ break;
	+ }
	+ case kPakeCredentialResponse: {
	+ _internal_set_pakecredentialresponse(from._internal_pakecredentialresponse());
	+ break;
	+ }
	+ case kPakeChallengeMessage: {
	+ _internal_set_pakechallengemessage(from._internal_pakechallengemessage());
	+ break;
	+ }
	+ case kWalletAuthenticationResponse: {
	+ _internal_set_walletauthenticationresponse(from._internal_walletauthenticationresponse());
	+ break;
	+ }
	+ case RESPONSEDATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+}
	+
	+void FullAuthenticationResponseData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:backup.FullAuthenticationResponseData)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void FullAuthenticationResponseData::CopyFrom(const FullAuthenticationResponseData& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:backup.FullAuthenticationResponseData)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool FullAuthenticationResponseData::IsInitialized() const {
	+ return true;
	+}
	+
	+void FullAuthenticationResponseData::InternalSwap(FullAuthenticationResponseData* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ swap(responseData_, other->responseData_);
	+ swap(_oneof_case_[0], other->_oneof_case_[0]);
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata FullAuthenticationResponseData::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class SimpleAuthenticationRequestData::_Internal {
	+ public:
	+};
	+
	+SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:backup.SimpleAuthenticationRequestData)
	+}
	+SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(const SimpleAuthenticationRequestData& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_backupid().empty()) {
	+ backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_backupid(),
	+ GetArena());
	+ }
	+ userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_userid().empty()) {
	+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
	+ GetArena());
	+ }
	+ // @@protoc_insertion_point(copy_constructor:backup.SimpleAuthenticationRequestData)
	+}
	+
	+void SimpleAuthenticationRequestData::SharedCtor() {
	+backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+SimpleAuthenticationRequestData::~SimpleAuthenticationRequestData() {
	+ // @@protoc_insertion_point(destructor:backup.SimpleAuthenticationRequestData)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void SimpleAuthenticationRequestData::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ backupid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+void SimpleAuthenticationRequestData::ArenaDtor(void* object) {
	+ SimpleAuthenticationRequestData* _this = reinterpret_cast< SimpleAuthenticationRequestData* >(object);
	+ (void)_this;
	+}
	+void SimpleAuthenticationRequestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void SimpleAuthenticationRequestData::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void SimpleAuthenticationRequestData::Clear() {
	+// @@protoc_insertion_point(message_clear_start:backup.SimpleAuthenticationRequestData)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ backupid_.ClearToEmpty();
	+ userid_.ClearToEmpty();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* SimpleAuthenticationRequestData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	+ while (!ctx->Done(&ptr)) {
	+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	+ CHK_(ptr);
	+ switch (tag >> 3) {
	+ // string backupID = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ auto str = _internal_mutable_backupid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SimpleAuthenticationRequestData.backupID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string userID = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_userid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SimpleAuthenticationRequestData.userID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ default: {
	+ handle_unusual:
	+ if ((tag & 7) == 4 \|\| tag == 0) {
	+ ctx->SetLastTag(tag);
	+ goto success;
	+ }
	+ ptr = UnknownFieldParse(tag,
	+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
	+ ptr, ctx);
	+ CHK_(ptr != nullptr);
	+ continue;
	+ }
	+ } // switch
	+ } // while
	+success:
	+ return ptr;
	+failure:
	+ ptr = nullptr;
	+ goto success;
	+#undef CHK_
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::uint8* SimpleAuthenticationRequestData::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:backup.SimpleAuthenticationRequestData)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // string backupID = 1;
	+ if (this->backupid().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_backupid().data(), static_cast<int>(this->_internal_backupid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "backup.SimpleAuthenticationRequestData.backupID");
	+ target = stream->WriteStringMaybeAliased(
	+ 1, this->_internal_backupid(), target);
	+ }
	+
	+ // string userID = 2;
	+ if (this->userid().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "backup.SimpleAuthenticationRequestData.userID");
	+ target = stream->WriteStringMaybeAliased(
	+ 2, this->_internal_userid(), target);
	+ }
	+
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	+ }
	+ // @@protoc_insertion_point(serialize_to_array_end:backup.SimpleAuthenticationRequestData)
	+ return target;
	+}
	+
	+size_t SimpleAuthenticationRequestData::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:backup.SimpleAuthenticationRequestData)
	+ size_t total_size = 0;
	+
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ // string backupID = 1;
	+ if (this->backupid().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_backupid());
	+ }
	+
	+ // string userID = 2;
	+ if (this->userid().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_userid());
	+ }
	+
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
	+ _internal_metadata_, total_size, &_cached_size_);
	+ }
	+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
	+ SetCachedSize(cached_size);
	+ return total_size;
	+}
	+
	+void SimpleAuthenticationRequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:backup.SimpleAuthenticationRequestData)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const SimpleAuthenticationRequestData* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SimpleAuthenticationRequestData>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.SimpleAuthenticationRequestData)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.SimpleAuthenticationRequestData)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void SimpleAuthenticationRequestData::MergeFrom(const SimpleAuthenticationRequestData& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:backup.SimpleAuthenticationRequestData)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ if (from.backupid().size() > 0) {
	+ _internal_set_backupid(from._internal_backupid());
	+ }
	+ if (from.userid().size() > 0) {
	+ _internal_set_userid(from._internal_userid());
	+ }
	+}
	+
	+void SimpleAuthenticationRequestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:backup.SimpleAuthenticationRequestData)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void SimpleAuthenticationRequestData::CopyFrom(const SimpleAuthenticationRequestData& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:backup.SimpleAuthenticationRequestData)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool SimpleAuthenticationRequestData::IsInitialized() const {
	+ return true;
	+}
	+
	+void SimpleAuthenticationRequestData::InternalSwap(SimpleAuthenticationRequestData* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ backupid_.Swap(&other->backupid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata SimpleAuthenticationRequestData::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class AuthenticationInformationData::_Internal {
	+ public:
	+};
	+
	+AuthenticationInformationData::AuthenticationInformationData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:backup.AuthenticationInformationData)
	+}
	+AuthenticationInformationData::AuthenticationInformationData(const AuthenticationInformationData& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ clear_has_data();
	+ switch (from.data_case()) {
	+ case kNonce: {
	+ _internal_set_nonce(from._internal_nonce());
	+ break;
	+ }
	+ case kRawMessage: {
	+ _internal_set_rawmessage(from._internal_rawmessage());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ // @@protoc_insertion_point(copy_constructor:backup.AuthenticationInformationData)
	+}
	+
	+void AuthenticationInformationData::SharedCtor() {
	+clear_has_data();
	+}
	+
	+AuthenticationInformationData::~AuthenticationInformationData() {
	+ // @@protoc_insertion_point(destructor:backup.AuthenticationInformationData)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void AuthenticationInformationData::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ if (has_data()) {
	+ clear_data();
	+ }
	+}
	+
	+void AuthenticationInformationData::ArenaDtor(void* object) {
	+ AuthenticationInformationData* _this = reinterpret_cast< AuthenticationInformationData* >(object);
	+ (void)_this;
	+}
	+void AuthenticationInformationData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void AuthenticationInformationData::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void AuthenticationInformationData::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:backup.AuthenticationInformationData)
	+ switch (data_case()) {
	+ case kNonce: {
	+ data_.nonce_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kRawMessage: {
	+ data_.rawmessage_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+
	+
	+void AuthenticationInformationData::Clear() {
	+// @@protoc_insertion_point(message_clear_start:backup.AuthenticationInformationData)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ clear_data();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* AuthenticationInformationData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	+ while (!ctx->Done(&ptr)) {
	+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	+ CHK_(ptr);
	+ switch (tag >> 3) {
	+ // bytes nonce = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ auto str = _internal_mutable_nonce();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes rawMessage = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_rawmessage();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ default: {
	+ handle_unusual:
	+ if ((tag & 7) == 4 \|\| tag == 0) {
	+ ctx->SetLastTag(tag);
	+ goto success;
	+ }
	+ ptr = UnknownFieldParse(tag,
	+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
	+ ptr, ctx);
	+ CHK_(ptr != nullptr);
	+ continue;
	+ }
	+ } // switch
	+ } // while
	+success:
	+ return ptr;
	+failure:
	+ ptr = nullptr;
	+ goto success;
	+#undef CHK_
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::uint8* AuthenticationInformationData::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:backup.AuthenticationInformationData)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // bytes nonce = 1;
	+ if (_internal_has_nonce()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 1, this->_internal_nonce(), target);
	+ }
	+
	+ // bytes rawMessage = 2;
	+ if (_internal_has_rawmessage()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 2, this->_internal_rawmessage(), target);
	+ }
	+
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	+ }
	+ // @@protoc_insertion_point(serialize_to_array_end:backup.AuthenticationInformationData)
	+ return target;
	+}
	+
	+size_t AuthenticationInformationData::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:backup.AuthenticationInformationData)
	+ size_t total_size = 0;
	+
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ switch (data_case()) {
	+ // bytes nonce = 1;
	+ case kNonce: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_nonce());
	+ break;
	+ }
	+ // bytes rawMessage = 2;
	+ case kRawMessage: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_rawmessage());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
	+ _internal_metadata_, total_size, &_cached_size_);
	+ }
	+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
	+ SetCachedSize(cached_size);
	+ return total_size;
	+}
	+
	+void AuthenticationInformationData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:backup.AuthenticationInformationData)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const AuthenticationInformationData* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<AuthenticationInformationData>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.AuthenticationInformationData)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.AuthenticationInformationData)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void AuthenticationInformationData::MergeFrom(const AuthenticationInformationData& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:backup.AuthenticationInformationData)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ switch (from.data_case()) {
	+ case kNonce: {
	+ _internal_set_nonce(from._internal_nonce());
	+ break;
	+ }
	+ case kRawMessage: {
	+ _internal_set_rawmessage(from._internal_rawmessage());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+}
	+
	+void AuthenticationInformationData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:backup.AuthenticationInformationData)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void AuthenticationInformationData::CopyFrom(const AuthenticationInformationData& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:backup.AuthenticationInformationData)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool AuthenticationInformationData::IsInitialized() const {
	+ return true;
	+}
	+
	+void AuthenticationInformationData::InternalSwap(AuthenticationInformationData* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ swap(data_, other->data_);
	+ swap(_oneof_case_[0], other->_oneof_case_[0]);
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata AuthenticationInformationData::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class CreateNewBackupRequest::_Internal {
	+ public:
	+ static const ::backup::FullAuthenticationRequestData& authenticationrequestdata(const CreateNewBackupRequest* msg);
	+ static const ::backup::AuthenticationInformationData& authenticationinformationdata(const CreateNewBackupRequest* msg);
	+};
	+
	+const ::backup::FullAuthenticationRequestData&
	+CreateNewBackupRequest::_Internal::authenticationrequestdata(const CreateNewBackupRequest* msg) {
	+ return *msg->data_.authenticationrequestdata_;
	+}
	+const ::backup::AuthenticationInformationData&
	+CreateNewBackupRequest::_Internal::authenticationinformationdata(const CreateNewBackupRequest* msg) {
	+ return *msg->data_.authenticationinformationdata_;
	+}
	+void CreateNewBackupRequest::set_allocated_authenticationrequestdata(::backup::FullAuthenticationRequestData* authenticationrequestdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (authenticationrequestdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationrequestdata);
	+ if (message_arena != submessage_arena) {
	+ authenticationrequestdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, authenticationrequestdata, submessage_arena);
	+ }
	+ set_has_authenticationrequestdata();
	+ data_.authenticationrequestdata_ = authenticationrequestdata;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.authenticationRequestData)
	+}
	+void CreateNewBackupRequest::set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (authenticationinformationdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationinformationdata);
	+ if (message_arena != submessage_arena) {
	+ authenticationinformationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, authenticationinformationdata, submessage_arena);
	+ }
	+ set_has_authenticationinformationdata();
	+ data_.authenticationinformationdata_ = authenticationinformationdata;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.authenticationInformationData)
	+}
	+CreateNewBackupRequest::CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:backup.CreateNewBackupRequest)
	+}
	+CreateNewBackupRequest::CreateNewBackupRequest(const CreateNewBackupRequest& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ clear_has_data();
	+ switch (from.data_case()) {
	+ case kAuthenticationRequestData: {
	+ _internal_mutable_authenticationrequestdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationrequestdata());
	+ break;
	+ }
	+ case kAuthenticationInformationData: {
	+ _internal_mutable_authenticationinformationdata()->::backup::AuthenticationInformationData::MergeFrom(from._internal_authenticationinformationdata());
	+ break;
	+ }
	+ case kNewCompactionChunk: {
	+ _internal_set_newcompactionchunk(from._internal_newcompactionchunk());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ // @@protoc_insertion_point(copy_constructor:backup.CreateNewBackupRequest)
	+}
	+
	+void CreateNewBackupRequest::SharedCtor() {
	+clear_has_data();
	+}
	+
	+CreateNewBackupRequest::~CreateNewBackupRequest() {
	+ // @@protoc_insertion_point(destructor:backup.CreateNewBackupRequest)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void CreateNewBackupRequest::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ if (has_data()) {
	+ clear_data();
	+ }
	+}
	+
	+void CreateNewBackupRequest::ArenaDtor(void* object) {
	+ CreateNewBackupRequest* _this = reinterpret_cast< CreateNewBackupRequest* >(object);
	+ (void)_this;
	+}
	+void CreateNewBackupRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void CreateNewBackupRequest::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void CreateNewBackupRequest::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:backup.CreateNewBackupRequest)
	+ switch (data_case()) {
	+ case kAuthenticationRequestData: {
	+ if (GetArena() == nullptr) {
	+ delete data_.authenticationrequestdata_;
	+ }
	+ break;
	+ }
	+ case kAuthenticationInformationData: {
	+ if (GetArena() == nullptr) {
	+ delete data_.authenticationinformationdata_;
	+ }
	+ break;
	+ }
	+ case kNewCompactionChunk: {
	+ data_.newcompactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+
	+
	+void CreateNewBackupRequest::Clear() {
	+// @@protoc_insertion_point(message_clear_start:backup.CreateNewBackupRequest)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ clear_data();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* CreateNewBackupRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	+ while (!ctx->Done(&ptr)) {
	+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	+ CHK_(ptr);
	+ switch (tag >> 3) {
	+ // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_authenticationrequestdata(), ptr);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // .backup.AuthenticationInformationData authenticationInformationData = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_authenticationinformationdata(), ptr);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes newCompactionChunk = 3;
	+ case 3:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ auto str = _internal_mutable_newcompactionchunk();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ default: {
	+ handle_unusual:
	+ if ((tag & 7) == 4 \|\| tag == 0) {
	+ ctx->SetLastTag(tag);
	+ goto success;
	+ }
	+ ptr = UnknownFieldParse(tag,
	+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
	+ ptr, ctx);
	+ CHK_(ptr != nullptr);
	+ continue;
	+ }
	+ } // switch
	+ } // while
	+success:
	+ return ptr;
	+failure:
	+ ptr = nullptr;
	+ goto success;
	+#undef CHK_
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::uint8* CreateNewBackupRequest::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:backup.CreateNewBackupRequest)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
	+ if (_internal_has_authenticationrequestdata()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 1, _Internal::authenticationrequestdata(this), target, stream);
	+ }
	+
	+ // .backup.AuthenticationInformationData authenticationInformationData = 2;
	+ if (_internal_has_authenticationinformationdata()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 2, _Internal::authenticationinformationdata(this), target, stream);
	+ }
	+
	+ // bytes newCompactionChunk = 3;
	+ if (_internal_has_newcompactionchunk()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 3, this->_internal_newcompactionchunk(), target);
	+ }
	+
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	+ }
	+ // @@protoc_insertion_point(serialize_to_array_end:backup.CreateNewBackupRequest)
	+ return target;
	+}
	+
	+size_t CreateNewBackupRequest::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:backup.CreateNewBackupRequest)
	+ size_t total_size = 0;
	+
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ switch (data_case()) {
	+ // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
	+ case kAuthenticationRequestData: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.authenticationrequestdata_);
	+ break;
	+ }
	+ // .backup.AuthenticationInformationData authenticationInformationData = 2;
	+ case kAuthenticationInformationData: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.authenticationinformationdata_);
	+ break;
	+ }
	+ // bytes newCompactionChunk = 3;
	+ case kNewCompactionChunk: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_newcompactionchunk());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
	+ _internal_metadata_, total_size, &_cached_size_);
	+ }
	+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
	+ SetCachedSize(cached_size);
	+ return total_size;
	+}
	+
	+void CreateNewBackupRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:backup.CreateNewBackupRequest)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const CreateNewBackupRequest* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CreateNewBackupRequest>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.CreateNewBackupRequest)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.CreateNewBackupRequest)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void CreateNewBackupRequest::MergeFrom(const CreateNewBackupRequest& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:backup.CreateNewBackupRequest)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ switch (from.data_case()) {
	+ case kAuthenticationRequestData: {
	+ _internal_mutable_authenticationrequestdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationrequestdata());
	+ break;
	+ }
	+ case kAuthenticationInformationData: {
	+ _internal_mutable_authenticationinformationdata()->::backup::AuthenticationInformationData::MergeFrom(from._internal_authenticationinformationdata());
	+ break;
	+ }
	+ case kNewCompactionChunk: {
	+ _internal_set_newcompactionchunk(from._internal_newcompactionchunk());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+}
	+
	+void CreateNewBackupRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:backup.CreateNewBackupRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void CreateNewBackupRequest::CopyFrom(const CreateNewBackupRequest& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:backup.CreateNewBackupRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool CreateNewBackupRequest::IsInitialized() const {
	+ return true;
	+}
	+
	+void CreateNewBackupRequest::InternalSwap(CreateNewBackupRequest* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ swap(data_, other->data_);
	+ swap(_oneof_case_[0], other->_oneof_case_[0]);
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata CreateNewBackupRequest::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+

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

	-class ResetKeyRequest::_Internal {
	+class CreateNewBackupResponse::_Internal {
	public:
	+ static const ::backup::FullAuthenticationResponseData& authenticationresponsedata(const CreateNewBackupResponse* msg);
	};

	-ResetKeyRequest::ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+const ::backup::FullAuthenticationResponseData&
	+CreateNewBackupResponse::_Internal::authenticationresponsedata(const CreateNewBackupResponse* msg) {
	+ return *msg->data_.authenticationresponsedata_;
	+}
	+void CreateNewBackupResponse::set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (authenticationresponsedata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationresponsedata);
	+ if (message_arena != submessage_arena) {
	+ authenticationresponsedata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, authenticationresponsedata, submessage_arena);
	+ }
	+ set_has_authenticationresponsedata();
	+ data_.authenticationresponsedata_ = authenticationresponsedata;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupResponse.authenticationResponseData)
	+}
	+CreateNewBackupResponse::CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	SharedCtor();
	RegisterArenaDtor(arena);
	- // @@protoc_insertion_point(arena_constructor:backup.ResetKeyRequest)
	+ // @@protoc_insertion_point(arena_constructor:backup.CreateNewBackupResponse)
	}
	-ResetKeyRequest::ResetKeyRequest(const ResetKeyRequest& from)
	+CreateNewBackupResponse::CreateNewBackupResponse(const CreateNewBackupResponse& from)
	: ::PROTOBUF_NAMESPACE_ID::Message() {
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	- userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- if (!from._internal_userid().empty()) {
	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
	- GetArena());
	- }
	clear_has_data();
	switch (from.data_case()) {
	- case kNewKey: {
	- _internal_set_newkey(from._internal_newkey());
	+ case kAuthenticationResponseData: {
	+ _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
	break;
	}
	- case kCompactionChunk: {
	- _internal_set_compactionchunk(from._internal_compactionchunk());
	+ case kBackupID: {
	+ _internal_set_backupid(from._internal_backupid());
	break;
	}
	case DATA_NOT_SET: {
	break;
	}
	}
	- // @@protoc_insertion_point(copy_constructor:backup.ResetKeyRequest)
	+ // @@protoc_insertion_point(copy_constructor:backup.CreateNewBackupResponse)
	}

	-void ResetKeyRequest::SharedCtor() {
	-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+void CreateNewBackupResponse::SharedCtor() {
	clear_has_data();
	}

	-ResetKeyRequest::~ResetKeyRequest() {
	- // @@protoc_insertion_point(destructor:backup.ResetKeyRequest)
	+CreateNewBackupResponse::~CreateNewBackupResponse() {
	+ // @@protoc_insertion_point(destructor:backup.CreateNewBackupResponse)
	SharedDtor();
	_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	-void ResetKeyRequest::SharedDtor() {
	+void CreateNewBackupResponse::SharedDtor() {
	GOOGLE_DCHECK(GetArena() == nullptr);
	- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	if (has_data()) {
	clear_data();
	}
	}

	-void ResetKeyRequest::ArenaDtor(void* object) {
	- ResetKeyRequest* _this = reinterpret_cast< ResetKeyRequest* >(object);
	+void CreateNewBackupResponse::ArenaDtor(void* object) {
	+ CreateNewBackupResponse* _this = reinterpret_cast< CreateNewBackupResponse* >(object);
	(void)_this;
	}
	-void ResetKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+void CreateNewBackupResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	}
	-void ResetKeyRequest::SetCachedSize(int size) const {
	+void CreateNewBackupResponse::SetCachedSize(int size) const {
	_cached_size_.Set(size);
	}

	-void ResetKeyRequest::clear_data() {
	-// @@protoc_insertion_point(one_of_clear_start:backup.ResetKeyRequest)
	+void CreateNewBackupResponse::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:backup.CreateNewBackupResponse)
	switch (data_case()) {
	- case kNewKey: {
	- data_.newkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ case kAuthenticationResponseData: {
	+ if (GetArena() == nullptr) {
	+ delete data_.authenticationresponsedata_;
	+ }
	break;
	}
	- case kCompactionChunk: {
	- data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ case kBackupID: {
	+ data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	break;
	}
	case DATA_NOT_SET: {
	@@ -288,46 +2082,36 @@
	}


	-void ResetKeyRequest::Clear() {
	-// @@protoc_insertion_point(message_clear_start:backup.ResetKeyRequest)
	+void CreateNewBackupResponse::Clear() {
	+// @@protoc_insertion_point(message_clear_start:backup.CreateNewBackupResponse)
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- userid_.ClearToEmpty();
	clear_data();
	_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	-const char* ResetKeyRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+const char* CreateNewBackupResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	while (!ctx->Done(&ptr)) {
	::PROTOBUF_NAMESPACE_ID::uint32 tag;
	ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	CHK_(ptr);
	switch (tag >> 3) {
	- // string userId = 1;
	+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
	case 1:
	if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	- auto str = _internal_mutable_userid();
	- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.ResetKeyRequest.userId"));
	+ ptr = ctx->ParseMessage(_internal_mutable_authenticationresponsedata(), ptr);
	CHK_(ptr);
	} else goto handle_unusual;
	continue;
	- // bytes newKey = 2;
	+ // string backupID = 2;
	case 2:
	if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	- auto str = _internal_mutable_newkey();
	- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	- CHK_(ptr);
	- } else goto handle_unusual;
	- continue;
	- // bytes compactionChunk = 3;
	- case 3:
	- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	- auto str = _internal_mutable_compactionchunk();
	+ auto str = _internal_mutable_backupid();
	ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.CreateNewBackupResponse.backupID"));
	CHK_(ptr);
	} else goto handle_unusual;
	continue;
	@@ -353,70 +2137,59 @@
	#undef CHK_
	}

	-::PROTOBUF_NAMESPACE_ID::uint8* ResetKeyRequest::_InternalSerialize(
	+::PROTOBUF_NAMESPACE_ID::uint8* CreateNewBackupResponse::_InternalSerialize(
	::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	- // @@protoc_insertion_point(serialize_to_array_start:backup.ResetKeyRequest)
	+ // @@protoc_insertion_point(serialize_to_array_start:backup.CreateNewBackupResponse)
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- // string userId = 1;
	- if (this->userid().size() > 0) {
	+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
	+ if (_internal_has_authenticationresponsedata()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 1, _Internal::authenticationresponsedata(this), target, stream);
	+ }
	+
	+ // string backupID = 2;
	+ if (_internal_has_backupid()) {
	::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	- this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
	+ this->_internal_backupid().data(), static_cast<int>(this->_internal_backupid().length()),
	::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	- "backup.ResetKeyRequest.userId");
	+ "backup.CreateNewBackupResponse.backupID");
	target = stream->WriteStringMaybeAliased(
	- 1, this->_internal_userid(), target);
	- }
	-
	- // bytes newKey = 2;
	- if (_internal_has_newkey()) {
	- target = stream->WriteBytesMaybeAliased(
	- 2, this->_internal_newkey(), target);
	- }
	-
	- // bytes compactionChunk = 3;
	- if (_internal_has_compactionchunk()) {
	- target = stream->WriteBytesMaybeAliased(
	- 3, this->_internal_compactionchunk(), target);
	+ 2, this->_internal_backupid(), target);
	}

	if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	}
	- // @@protoc_insertion_point(serialize_to_array_end:backup.ResetKeyRequest)
	+ // @@protoc_insertion_point(serialize_to_array_end:backup.CreateNewBackupResponse)
	return target;
	}

	-size_t ResetKeyRequest::ByteSizeLong() const {
	-// @@protoc_insertion_point(message_byte_size_start:backup.ResetKeyRequest)
	+size_t CreateNewBackupResponse::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:backup.CreateNewBackupResponse)
	size_t total_size = 0;

	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- // string userId = 1;
	- if (this->userid().size() > 0) {
	- total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	- this->_internal_userid());
	- }
	-
	switch (data_case()) {
	- // bytes newKey = 2;
	- case kNewKey: {
	+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
	+ case kAuthenticationResponseData: {
	total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	- this->_internal_newkey());
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.authenticationresponsedata_);
	break;
	}
	- // bytes compactionChunk = 3;
	- case kCompactionChunk: {
	+ // string backupID = 2;
	+ case kBackupID: {
	total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	- this->_internal_compactionchunk());
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_backupid());
	break;
	}
	case DATA_NOT_SET: {
	@@ -432,38 +2205,35 @@
	return total_size;
	}

	-void ResetKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	-// @@protoc_insertion_point(generalized_merge_from_start:backup.ResetKeyRequest)
	+void CreateNewBackupResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:backup.CreateNewBackupResponse)
	GOOGLE_DCHECK_NE(&from, this);
	- const ResetKeyRequest* source =
	- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResetKeyRequest>(
	+ const CreateNewBackupResponse* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CreateNewBackupResponse>(
	&from);
	if (source == nullptr) {
	- // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.ResetKeyRequest)
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.CreateNewBackupResponse)
	::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	} else {
	- // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.ResetKeyRequest)
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.CreateNewBackupResponse)
	MergeFrom(*source);
	}
	}

	-void ResetKeyRequest::MergeFrom(const ResetKeyRequest& from) {
	-// @@protoc_insertion_point(class_specific_merge_from_start:backup.ResetKeyRequest)
	+void CreateNewBackupResponse::MergeFrom(const CreateNewBackupResponse& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:backup.CreateNewBackupResponse)
	GOOGLE_DCHECK_NE(&from, this);
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- if (from.userid().size() > 0) {
	- _internal_set_userid(from._internal_userid());
	- }
	switch (from.data_case()) {
	- case kNewKey: {
	- _internal_set_newkey(from._internal_newkey());
	+ case kAuthenticationResponseData: {
	+ _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
	break;
	}
	- case kCompactionChunk: {
	- _internal_set_compactionchunk(from._internal_compactionchunk());
	+ case kBackupID: {
	+ _internal_set_backupid(from._internal_backupid());
	break;
	}
	case DATA_NOT_SET: {
	@@ -472,33 +2242,32 @@
	}
	}

	-void ResetKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	-// @@protoc_insertion_point(generalized_copy_from_start:backup.ResetKeyRequest)
	+void CreateNewBackupResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:backup.CreateNewBackupResponse)
	if (&from == this) return;
	Clear();
	MergeFrom(from);
	}

	-void ResetKeyRequest::CopyFrom(const ResetKeyRequest& from) {
	-// @@protoc_insertion_point(class_specific_copy_from_start:backup.ResetKeyRequest)
	+void CreateNewBackupResponse::CopyFrom(const CreateNewBackupResponse& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:backup.CreateNewBackupResponse)
	if (&from == this) return;
	Clear();
	MergeFrom(from);
	}

	-bool ResetKeyRequest::IsInitialized() const {
	+bool CreateNewBackupResponse::IsInitialized() const {
	return true;
	}

	-void ResetKeyRequest::InternalSwap(ResetKeyRequest* other) {
	+void CreateNewBackupResponse::InternalSwap(CreateNewBackupResponse* other) {
	using std::swap;
	_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	swap(data_, other->data_);
	swap(_oneof_case_[0], other->_oneof_case_[0]);
	}

	-::PROTOBUF_NAMESPACE_ID::Metadata ResetKeyRequest::GetMetadata() const {
	+::PROTOBUF_NAMESPACE_ID::Metadata CreateNewBackupResponse::GetMetadata() const {
	return GetMetadataStatic();
	}

	@@ -507,8 +2276,13 @@

	class SendLogRequest::_Internal {
	public:
	+ static const ::backup::SimpleAuthenticationRequestData& authenticationdata(const SendLogRequest* msg);
	};

	+const ::backup::SimpleAuthenticationRequestData&
	+SendLogRequest::_Internal::authenticationdata(const SendLogRequest* msg) {
	+ return *msg->authenticationdata_;
	+}
	SendLogRequest::SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	SharedCtor();
	@@ -518,22 +2292,22 @@
	SendLogRequest::SendLogRequest(const SendLogRequest& from)
	: ::PROTOBUF_NAMESPACE_ID::Message() {
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	- userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- if (!from._internal_userid().empty()) {
	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
	+ logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_logdata().empty()) {
	+ logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_logdata(),
	GetArena());
	}
	- data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- if (!from._internal_data().empty()) {
	- data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(),
	- GetArena());
	+ if (from._internal_has_authenticationdata()) {
	+ authenticationdata_ = new ::backup::SimpleAuthenticationRequestData(*from.authenticationdata_);
	+ } else {
	+ authenticationdata_ = nullptr;
	}
	// @@protoc_insertion_point(copy_constructor:backup.SendLogRequest)
	}

	void SendLogRequest::SharedCtor() {
	-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	-data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+authenticationdata_ = nullptr;
	}

	SendLogRequest::~SendLogRequest() {
	@@ -544,8 +2318,8 @@

	void SendLogRequest::SharedDtor() {
	GOOGLE_DCHECK(GetArena() == nullptr);
	- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ logdata_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (this != internal_default_instance()) delete authenticationdata_;
	}

	void SendLogRequest::ArenaDtor(void* object) {
	@@ -564,8 +2338,11 @@
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- userid_.ClearToEmpty();
	- data_.ClearToEmpty();
	+ logdata_.ClearToEmpty();
	+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
	+ delete authenticationdata_;
	+ }
	+ authenticationdata_ = nullptr;
	_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	@@ -576,19 +2353,17 @@
	ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	CHK_(ptr);
	switch (tag >> 3) {
	- // string userId = 1;
	+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
	case 1:
	if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	- auto str = _internal_mutable_userid();
	- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SendLogRequest.userId"));
	+ ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr);
	CHK_(ptr);
	} else goto handle_unusual;
	continue;
	- // bytes data = 2;
	+ // bytes logData = 2;
	case 2:
	if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	- auto str = _internal_mutable_data();
	+ auto str = _internal_mutable_logdata();
	ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	CHK_(ptr);
	} else goto handle_unusual;
	@@ -621,20 +2396,18 @@
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- // string userId = 1;
	- if (this->userid().size() > 0) {
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	- this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	- "backup.SendLogRequest.userId");
	- target = stream->WriteStringMaybeAliased(
	- 1, this->_internal_userid(), target);
	+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
	+ if (this->has_authenticationdata()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 1, _Internal::authenticationdata(this), target, stream);
	}

	- // bytes data = 2;
	- if (this->data().size() > 0) {
	+ // bytes logData = 2;
	+ if (this->logdata().size() > 0) {
	target = stream->WriteBytesMaybeAliased(
	- 2, this->_internal_data(), target);
	+ 2, this->_internal_logdata(), target);
	}

	if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	@@ -653,18 +2426,18 @@
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- // string userId = 1;
	- if (this->userid().size() > 0) {
	+ // bytes logData = 2;
	+ if (this->logdata().size() > 0) {
	total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	- this->_internal_userid());
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_logdata());
	}

	- // bytes data = 2;
	- if (this->data().size() > 0) {
	+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
	+ if (this->has_authenticationdata()) {
	total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	- this->_internal_data());
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *authenticationdata_);
	}

	if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	@@ -698,11 +2471,11 @@
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- if (from.userid().size() > 0) {
	- _internal_set_userid(from._internal_userid());
	+ if (from.logdata().size() > 0) {
	+ _internal_set_logdata(from._internal_logdata());
	}
	- if (from.data().size() > 0) {
	- _internal_set_data(from._internal_data());
	+ if (from.has_authenticationdata()) {
	+ _internal_mutable_authenticationdata()->::backup::SimpleAuthenticationRequestData::MergeFrom(from._internal_authenticationdata());
	}
	}

	@@ -727,8 +2500,8 @@
	void SendLogRequest::InternalSwap(SendLogRequest* other) {
	using std::swap;
	_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	- data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ logdata_.Swap(&other->logdata_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ swap(authenticationdata_, other->authenticationdata_);
	}

	::PROTOBUF_NAMESPACE_ID::Metadata SendLogRequest::GetMetadata() const {
	@@ -738,91 +2511,81 @@

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

	-class PullBackupKeyRequest::_Internal {
	+class RecoverBackupKeyRequest::_Internal {
	public:
	+ static const ::backup::FullAuthenticationRequestData& authenticationdata(const RecoverBackupKeyRequest* msg);
	};

	-PullBackupKeyRequest::PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+const ::backup::FullAuthenticationRequestData&
	+RecoverBackupKeyRequest::_Internal::authenticationdata(const RecoverBackupKeyRequest* msg) {
	+ return *msg->authenticationdata_;
	+}
	+RecoverBackupKeyRequest::RecoverBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	SharedCtor();
	RegisterArenaDtor(arena);
	- // @@protoc_insertion_point(arena_constructor:backup.PullBackupKeyRequest)
	+ // @@protoc_insertion_point(arena_constructor:backup.RecoverBackupKeyRequest)
	}
	-PullBackupKeyRequest::PullBackupKeyRequest(const PullBackupKeyRequest& from)
	+RecoverBackupKeyRequest::RecoverBackupKeyRequest(const RecoverBackupKeyRequest& from)
	: ::PROTOBUF_NAMESPACE_ID::Message() {
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	- userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- if (!from._internal_userid().empty()) {
	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
	- GetArena());
	- }
	- pakekey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- if (!from._internal_pakekey().empty()) {
	- pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakekey(),
	- GetArena());
	+ if (from._internal_has_authenticationdata()) {
	+ authenticationdata_ = new ::backup::FullAuthenticationRequestData(*from.authenticationdata_);
	+ } else {
	+ authenticationdata_ = nullptr;
	}
	- // @@protoc_insertion_point(copy_constructor:backup.PullBackupKeyRequest)
	+ // @@protoc_insertion_point(copy_constructor:backup.RecoverBackupKeyRequest)
	}

	-void PullBackupKeyRequest::SharedCtor() {
	-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	-pakekey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+void RecoverBackupKeyRequest::SharedCtor() {
	+authenticationdata_ = nullptr;
	}

	-PullBackupKeyRequest::~PullBackupKeyRequest() {
	- // @@protoc_insertion_point(destructor:backup.PullBackupKeyRequest)
	+RecoverBackupKeyRequest::~RecoverBackupKeyRequest() {
	+ // @@protoc_insertion_point(destructor:backup.RecoverBackupKeyRequest)
	SharedDtor();
	_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	-void PullBackupKeyRequest::SharedDtor() {
	+void RecoverBackupKeyRequest::SharedDtor() {
	GOOGLE_DCHECK(GetArena() == nullptr);
	- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- pakekey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (this != internal_default_instance()) delete authenticationdata_;
	}

	-void PullBackupKeyRequest::ArenaDtor(void* object) {
	- PullBackupKeyRequest* _this = reinterpret_cast< PullBackupKeyRequest* >(object);
	+void RecoverBackupKeyRequest::ArenaDtor(void* object) {
	+ RecoverBackupKeyRequest* _this = reinterpret_cast< RecoverBackupKeyRequest* >(object);
	(void)_this;
	}
	-void PullBackupKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+void RecoverBackupKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	}
	-void PullBackupKeyRequest::SetCachedSize(int size) const {
	+void RecoverBackupKeyRequest::SetCachedSize(int size) const {
	_cached_size_.Set(size);
	}

	-void PullBackupKeyRequest::Clear() {
	-// @@protoc_insertion_point(message_clear_start:backup.PullBackupKeyRequest)
	+void RecoverBackupKeyRequest::Clear() {
	+// @@protoc_insertion_point(message_clear_start:backup.RecoverBackupKeyRequest)
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- userid_.ClearToEmpty();
	- pakekey_.ClearToEmpty();
	+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
	+ delete authenticationdata_;
	+ }
	+ authenticationdata_ = nullptr;
	_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	-const char* PullBackupKeyRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+const char* RecoverBackupKeyRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	while (!ctx->Done(&ptr)) {
	::PROTOBUF_NAMESPACE_ID::uint32 tag;
	ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	CHK_(ptr);
	switch (tag >> 3) {
	- // string userId = 1;
	+ // .backup.FullAuthenticationRequestData authenticationData = 1;
	case 1:
	if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	- auto str = _internal_mutable_userid();
	- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupKeyRequest.userId"));
	- CHK_(ptr);
	- } else goto handle_unusual;
	- continue;
	- // bytes pakeKey = 2;
	- case 2:
	- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	- auto str = _internal_mutable_pakekey();
	- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr);
	CHK_(ptr);
	} else goto handle_unusual;
	continue;
	@@ -848,56 +2611,41 @@
	#undef CHK_
	}

	-::PROTOBUF_NAMESPACE_ID::uint8* PullBackupKeyRequest::_InternalSerialize(
	+::PROTOBUF_NAMESPACE_ID::uint8* RecoverBackupKeyRequest::_InternalSerialize(
	::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	- // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupKeyRequest)
	+ // @@protoc_insertion_point(serialize_to_array_start:backup.RecoverBackupKeyRequest)
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- // string userId = 1;
	- if (this->userid().size() > 0) {
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	- this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	- "backup.PullBackupKeyRequest.userId");
	- target = stream->WriteStringMaybeAliased(
	- 1, this->_internal_userid(), target);
	- }
	-
	- // bytes pakeKey = 2;
	- if (this->pakekey().size() > 0) {
	- target = stream->WriteBytesMaybeAliased(
	- 2, this->_internal_pakekey(), target);
	+ // .backup.FullAuthenticationRequestData authenticationData = 1;
	+ if (this->has_authenticationdata()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 1, _Internal::authenticationdata(this), target, stream);
	}

	if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	}
	- // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupKeyRequest)
	+ // @@protoc_insertion_point(serialize_to_array_end:backup.RecoverBackupKeyRequest)
	return target;
	}

	-size_t PullBackupKeyRequest::ByteSizeLong() const {
	-// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupKeyRequest)
	+size_t RecoverBackupKeyRequest::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:backup.RecoverBackupKeyRequest)
	size_t total_size = 0;

	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- // string userId = 1;
	- if (this->userid().size() > 0) {
	- total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	- this->_internal_userid());
	- }
	-
	- // bytes pakeKey = 2;
	- if (this->pakekey().size() > 0) {
	+ // .backup.FullAuthenticationRequestData authenticationData = 1;
	+ if (this->has_authenticationdata()) {
	total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	- this->_internal_pakekey());
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *authenticationdata_);
	}

	if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	@@ -909,136 +2657,229 @@
	return total_size;
	}

	-void PullBackupKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupKeyRequest)
	+void RecoverBackupKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:backup.RecoverBackupKeyRequest)
	GOOGLE_DCHECK_NE(&from, this);
	- const PullBackupKeyRequest* source =
	- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupKeyRequest>(
	+ const RecoverBackupKeyRequest* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RecoverBackupKeyRequest>(
	&from);
	if (source == nullptr) {
	- // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupKeyRequest)
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.RecoverBackupKeyRequest)
	::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	} else {
	- // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupKeyRequest)
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.RecoverBackupKeyRequest)
	MergeFrom(*source);
	}
	}

	-void PullBackupKeyRequest::MergeFrom(const PullBackupKeyRequest& from) {
	-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupKeyRequest)
	+void RecoverBackupKeyRequest::MergeFrom(const RecoverBackupKeyRequest& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:backup.RecoverBackupKeyRequest)
	GOOGLE_DCHECK_NE(&from, this);
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- if (from.userid().size() > 0) {
	- _internal_set_userid(from._internal_userid());
	- }
	- if (from.pakekey().size() > 0) {
	- _internal_set_pakekey(from._internal_pakekey());
	+ if (from.has_authenticationdata()) {
	+ _internal_mutable_authenticationdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationdata());
	}
	}

	-void PullBackupKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupKeyRequest)
	+void RecoverBackupKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:backup.RecoverBackupKeyRequest)
	if (&from == this) return;
	Clear();
	MergeFrom(from);
	}

	-void PullBackupKeyRequest::CopyFrom(const PullBackupKeyRequest& from) {
	-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupKeyRequest)
	+void RecoverBackupKeyRequest::CopyFrom(const RecoverBackupKeyRequest& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:backup.RecoverBackupKeyRequest)
	if (&from == this) return;
	Clear();
	MergeFrom(from);
	}

	-bool PullBackupKeyRequest::IsInitialized() const {
	+bool RecoverBackupKeyRequest::IsInitialized() const {
	return true;
	}

	-void PullBackupKeyRequest::InternalSwap(PullBackupKeyRequest* other) {
	+void RecoverBackupKeyRequest::InternalSwap(RecoverBackupKeyRequest* other) {
	using std::swap;
	_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	- pakekey_.Swap(&other->pakekey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ swap(authenticationdata_, other->authenticationdata_);
	}

	-::PROTOBUF_NAMESPACE_ID::Metadata PullBackupKeyRequest::GetMetadata() const {
	+::PROTOBUF_NAMESPACE_ID::Metadata RecoverBackupKeyRequest::GetMetadata() const {
	return GetMetadataStatic();
	}


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

	-class PullBackupKeyResponse::_Internal {
	+class RecoverBackupKeyResponse::_Internal {
	public:
	+ static const ::backup::FullAuthenticationResponseData& authenticationresponsedata(const RecoverBackupKeyResponse* msg);
	+ static const ::backup::AuthenticationInformationData& authenticationinformationdata(const RecoverBackupKeyResponse* msg);
	};

	-PullBackupKeyResponse::PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+const ::backup::FullAuthenticationResponseData&
	+RecoverBackupKeyResponse::_Internal::authenticationresponsedata(const RecoverBackupKeyResponse* msg) {
	+ return *msg->data_.authenticationresponsedata_;
	+}
	+const ::backup::AuthenticationInformationData&
	+RecoverBackupKeyResponse::_Internal::authenticationinformationdata(const RecoverBackupKeyResponse* msg) {
	+ return *msg->data_.authenticationinformationdata_;
	+}
	+void RecoverBackupKeyResponse::set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (authenticationresponsedata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationresponsedata);
	+ if (message_arena != submessage_arena) {
	+ authenticationresponsedata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, authenticationresponsedata, submessage_arena);
	+ }
	+ set_has_authenticationresponsedata();
	+ data_.authenticationresponsedata_ = authenticationresponsedata;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyResponse.authenticationResponseData)
	+}
	+void RecoverBackupKeyResponse::set_allocated_authenticationinformationdata(::backup::AuthenticationInformationData* authenticationinformationdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (authenticationinformationdata) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationinformationdata);
	+ if (message_arena != submessage_arena) {
	+ authenticationinformationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, authenticationinformationdata, submessage_arena);
	+ }
	+ set_has_authenticationinformationdata();
	+ data_.authenticationinformationdata_ = authenticationinformationdata;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyResponse.authenticationInformationData)
	+}
	+RecoverBackupKeyResponse::RecoverBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	SharedCtor();
	RegisterArenaDtor(arena);
	- // @@protoc_insertion_point(arena_constructor:backup.PullBackupKeyResponse)
	+ // @@protoc_insertion_point(arena_constructor:backup.RecoverBackupKeyResponse)
	}
	-PullBackupKeyResponse::PullBackupKeyResponse(const PullBackupKeyResponse& from)
	+RecoverBackupKeyResponse::RecoverBackupKeyResponse(const RecoverBackupKeyResponse& from)
	: ::PROTOBUF_NAMESPACE_ID::Message() {
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	- encryptedbackupkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- if (!from._internal_encryptedbackupkey().empty()) {
	- encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_encryptedbackupkey(),
	- GetArena());
	+ clear_has_data();
	+ switch (from.data_case()) {
	+ case kAuthenticationResponseData: {
	+ _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
	+ break;
	+ }
	+ case kAuthenticationInformationData: {
	+ _internal_mutable_authenticationinformationdata()->::backup::AuthenticationInformationData::MergeFrom(from._internal_authenticationinformationdata());
	+ break;
	+ }
	+ case kBackupID: {
	+ _internal_set_backupid(from._internal_backupid());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	}
	- // @@protoc_insertion_point(copy_constructor:backup.PullBackupKeyResponse)
	+ // @@protoc_insertion_point(copy_constructor:backup.RecoverBackupKeyResponse)
	}

	-void PullBackupKeyResponse::SharedCtor() {
	-encryptedbackupkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+void RecoverBackupKeyResponse::SharedCtor() {
	+clear_has_data();
	}

	-PullBackupKeyResponse::~PullBackupKeyResponse() {
	- // @@protoc_insertion_point(destructor:backup.PullBackupKeyResponse)
	+RecoverBackupKeyResponse::~RecoverBackupKeyResponse() {
	+ // @@protoc_insertion_point(destructor:backup.RecoverBackupKeyResponse)
	SharedDtor();
	_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	-void PullBackupKeyResponse::SharedDtor() {
	+void RecoverBackupKeyResponse::SharedDtor() {
	GOOGLE_DCHECK(GetArena() == nullptr);
	- encryptedbackupkey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (has_data()) {
	+ clear_data();
	+ }
	}

	-void PullBackupKeyResponse::ArenaDtor(void* object) {
	- PullBackupKeyResponse* _this = reinterpret_cast< PullBackupKeyResponse* >(object);
	+void RecoverBackupKeyResponse::ArenaDtor(void* object) {
	+ RecoverBackupKeyResponse* _this = reinterpret_cast< RecoverBackupKeyResponse* >(object);
	(void)_this;
	}
	-void PullBackupKeyResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+void RecoverBackupKeyResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	}
	-void PullBackupKeyResponse::SetCachedSize(int size) const {
	+void RecoverBackupKeyResponse::SetCachedSize(int size) const {
	_cached_size_.Set(size);
	}

	-void PullBackupKeyResponse::Clear() {
	-// @@protoc_insertion_point(message_clear_start:backup.PullBackupKeyResponse)
	+void RecoverBackupKeyResponse::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:backup.RecoverBackupKeyResponse)
	+ switch (data_case()) {
	+ case kAuthenticationResponseData: {
	+ if (GetArena() == nullptr) {
	+ delete data_.authenticationresponsedata_;
	+ }
	+ break;
	+ }
	+ case kAuthenticationInformationData: {
	+ if (GetArena() == nullptr) {
	+ delete data_.authenticationinformationdata_;
	+ }
	+ break;
	+ }
	+ case kBackupID: {
	+ data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+
	+
	+void RecoverBackupKeyResponse::Clear() {
	+// @@protoc_insertion_point(message_clear_start:backup.RecoverBackupKeyResponse)
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- encryptedbackupkey_.ClearToEmpty();
	+ clear_data();
	_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	-const char* PullBackupKeyResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+const char* RecoverBackupKeyResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	while (!ctx->Done(&ptr)) {
	::PROTOBUF_NAMESPACE_ID::uint32 tag;
	ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	CHK_(ptr);
	switch (tag >> 3) {
	- // bytes encryptedBackupKey = 1;
	+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
	case 1:
	if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	- auto str = _internal_mutable_encryptedbackupkey();
	+ ptr = ctx->ParseMessage(_internal_mutable_authenticationresponsedata(), ptr);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // .backup.AuthenticationInformationData authenticationInformationData = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_authenticationinformationdata(), ptr);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string backupID = 3;
	+ case 3:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ auto str = _internal_mutable_backupid();
	ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.RecoverBackupKeyResponse.backupID"));
	CHK_(ptr);
	} else goto handle_unusual;
	continue;
	@@ -1064,41 +2905,80 @@
	#undef CHK_
	}

	-::PROTOBUF_NAMESPACE_ID::uint8* PullBackupKeyResponse::_InternalSerialize(
	+::PROTOBUF_NAMESPACE_ID::uint8* RecoverBackupKeyResponse::_InternalSerialize(
	::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	- // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupKeyResponse)
	+ // @@protoc_insertion_point(serialize_to_array_start:backup.RecoverBackupKeyResponse)
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- // bytes encryptedBackupKey = 1;
	- if (this->encryptedbackupkey().size() > 0) {
	- target = stream->WriteBytesMaybeAliased(
	- 1, this->_internal_encryptedbackupkey(), target);
	+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
	+ if (_internal_has_authenticationresponsedata()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 1, _Internal::authenticationresponsedata(this), target, stream);
	+ }
	+
	+ // .backup.AuthenticationInformationData authenticationInformationData = 2;
	+ if (_internal_has_authenticationinformationdata()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 2, _Internal::authenticationinformationdata(this), target, stream);
	+ }
	+
	+ // string backupID = 3;
	+ if (_internal_has_backupid()) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_backupid().data(), static_cast<int>(this->_internal_backupid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "backup.RecoverBackupKeyResponse.backupID");
	+ target = stream->WriteStringMaybeAliased(
	+ 3, this->_internal_backupid(), target);
	}

	if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	}
	- // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupKeyResponse)
	+ // @@protoc_insertion_point(serialize_to_array_end:backup.RecoverBackupKeyResponse)
	return target;
	}

	-size_t PullBackupKeyResponse::ByteSizeLong() const {
	-// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupKeyResponse)
	+size_t RecoverBackupKeyResponse::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:backup.RecoverBackupKeyResponse)
	size_t total_size = 0;

	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- // bytes encryptedBackupKey = 1;
	- if (this->encryptedbackupkey().size() > 0) {
	- total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	- this->_internal_encryptedbackupkey());
	+ switch (data_case()) {
	+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
	+ case kAuthenticationResponseData: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.authenticationresponsedata_);
	+ break;
	+ }
	+ // .backup.AuthenticationInformationData authenticationInformationData = 2;
	+ case kAuthenticationInformationData: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.authenticationinformationdata_);
	+ break;
	+ }
	+ // string backupID = 3;
	+ case kBackupID: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_backupid());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	}
	-
	if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
	_internal_metadata_, total_size, &_cached_size_);
	@@ -1108,149 +2988,154 @@
	return total_size;
	}

	-void PullBackupKeyResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupKeyResponse)
	+void RecoverBackupKeyResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:backup.RecoverBackupKeyResponse)
	GOOGLE_DCHECK_NE(&from, this);
	- const PullBackupKeyResponse* source =
	- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupKeyResponse>(
	+ const RecoverBackupKeyResponse* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RecoverBackupKeyResponse>(
	&from);
	if (source == nullptr) {
	- // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupKeyResponse)
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.RecoverBackupKeyResponse)
	::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	} else {
	- // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupKeyResponse)
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.RecoverBackupKeyResponse)
	MergeFrom(*source);
	}
	}

	-void PullBackupKeyResponse::MergeFrom(const PullBackupKeyResponse& from) {
	-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupKeyResponse)
	+void RecoverBackupKeyResponse::MergeFrom(const RecoverBackupKeyResponse& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:backup.RecoverBackupKeyResponse)
	GOOGLE_DCHECK_NE(&from, this);
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- if (from.encryptedbackupkey().size() > 0) {
	- _internal_set_encryptedbackupkey(from._internal_encryptedbackupkey());
	+ switch (from.data_case()) {
	+ case kAuthenticationResponseData: {
	+ _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
	+ break;
	+ }
	+ case kAuthenticationInformationData: {
	+ _internal_mutable_authenticationinformationdata()->::backup::AuthenticationInformationData::MergeFrom(from._internal_authenticationinformationdata());
	+ break;
	+ }
	+ case kBackupID: {
	+ _internal_set_backupid(from._internal_backupid());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	}
	}

	-void PullBackupKeyResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupKeyResponse)
	+void RecoverBackupKeyResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:backup.RecoverBackupKeyResponse)
	if (&from == this) return;
	Clear();
	MergeFrom(from);
	}

	-void PullBackupKeyResponse::CopyFrom(const PullBackupKeyResponse& from) {
	-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupKeyResponse)
	+void RecoverBackupKeyResponse::CopyFrom(const RecoverBackupKeyResponse& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:backup.RecoverBackupKeyResponse)
	if (&from == this) return;
	Clear();
	MergeFrom(from);
	}

	-bool PullBackupKeyResponse::IsInitialized() const {
	+bool RecoverBackupKeyResponse::IsInitialized() const {
	return true;
	}

	-void PullBackupKeyResponse::InternalSwap(PullBackupKeyResponse* other) {
	+void RecoverBackupKeyResponse::InternalSwap(RecoverBackupKeyResponse* other) {
	using std::swap;
	_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	- encryptedbackupkey_.Swap(&other->encryptedbackupkey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ swap(data_, other->data_);
	+ swap(_oneof_case_[0], other->_oneof_case_[0]);
	}

	-::PROTOBUF_NAMESPACE_ID::Metadata PullBackupKeyResponse::GetMetadata() const {
	+::PROTOBUF_NAMESPACE_ID::Metadata RecoverBackupKeyResponse::GetMetadata() const {
	return GetMetadataStatic();
	}


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

	-class PullCompactionRequest::_Internal {
	+class PullBackupRequest::_Internal {
	public:
	+ static const ::backup::SimpleAuthenticationRequestData& authenticationdata(const PullBackupRequest* msg);
	};

	-PullCompactionRequest::PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+const ::backup::SimpleAuthenticationRequestData&
	+PullBackupRequest::_Internal::authenticationdata(const PullBackupRequest* msg) {
	+ return *msg->authenticationdata_;
	+}
	+PullBackupRequest::PullBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	SharedCtor();
	RegisterArenaDtor(arena);
	- // @@protoc_insertion_point(arena_constructor:backup.PullCompactionRequest)
	+ // @@protoc_insertion_point(arena_constructor:backup.PullBackupRequest)
	}
	-PullCompactionRequest::PullCompactionRequest(const PullCompactionRequest& from)
	+PullBackupRequest::PullBackupRequest(const PullBackupRequest& from)
	: ::PROTOBUF_NAMESPACE_ID::Message() {
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	- userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- if (!from._internal_userid().empty()) {
	- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
	- GetArena());
	- }
	- message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- if (!from._internal_message().empty()) {
	- message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_message(),
	- GetArena());
	+ if (from._internal_has_authenticationdata()) {
	+ authenticationdata_ = new ::backup::SimpleAuthenticationRequestData(*from.authenticationdata_);
	+ } else {
	+ authenticationdata_ = nullptr;
	}
	- // @@protoc_insertion_point(copy_constructor:backup.PullCompactionRequest)
	+ // @@protoc_insertion_point(copy_constructor:backup.PullBackupRequest)
	}

	-void PullCompactionRequest::SharedCtor() {
	-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	-message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+void PullBackupRequest::SharedCtor() {
	+authenticationdata_ = nullptr;
	}

	-PullCompactionRequest::~PullCompactionRequest() {
	- // @@protoc_insertion_point(destructor:backup.PullCompactionRequest)
	+PullBackupRequest::~PullBackupRequest() {
	+ // @@protoc_insertion_point(destructor:backup.PullBackupRequest)
	SharedDtor();
	_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	-void PullCompactionRequest::SharedDtor() {
	+void PullBackupRequest::SharedDtor() {
	GOOGLE_DCHECK(GetArena() == nullptr);
	- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	- message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (this != internal_default_instance()) delete authenticationdata_;
	}

	-void PullCompactionRequest::ArenaDtor(void* object) {
	- PullCompactionRequest* _this = reinterpret_cast< PullCompactionRequest* >(object);
	+void PullBackupRequest::ArenaDtor(void* object) {
	+ PullBackupRequest* _this = reinterpret_cast< PullBackupRequest* >(object);
	(void)_this;
	}
	-void PullCompactionRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+void PullBackupRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	}
	-void PullCompactionRequest::SetCachedSize(int size) const {
	+void PullBackupRequest::SetCachedSize(int size) const {
	_cached_size_.Set(size);
	}

	-void PullCompactionRequest::Clear() {
	-// @@protoc_insertion_point(message_clear_start:backup.PullCompactionRequest)
	+void PullBackupRequest::Clear() {
	+// @@protoc_insertion_point(message_clear_start:backup.PullBackupRequest)
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- userid_.ClearToEmpty();
	- message_.ClearToEmpty();
	+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
	+ delete authenticationdata_;
	+ }
	+ authenticationdata_ = nullptr;
	_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	-const char* PullCompactionRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+const char* PullBackupRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	while (!ctx->Done(&ptr)) {
	::PROTOBUF_NAMESPACE_ID::uint32 tag;
	ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	CHK_(ptr);
	switch (tag >> 3) {
	- // string userId = 1;
	+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
	case 1:
	if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	- auto str = _internal_mutable_userid();
	- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullCompactionRequest.userId"));
	- CHK_(ptr);
	- } else goto handle_unusual;
	- continue;
	- // bytes message = 2;
	- case 2:
	- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	- auto str = _internal_mutable_message();
	- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr);
	CHK_(ptr);
	} else goto handle_unusual;
	continue;
	@@ -1276,56 +3161,41 @@
	#undef CHK_
	}

	-::PROTOBUF_NAMESPACE_ID::uint8* PullCompactionRequest::_InternalSerialize(
	+::PROTOBUF_NAMESPACE_ID::uint8* PullBackupRequest::_InternalSerialize(
	::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	- // @@protoc_insertion_point(serialize_to_array_start:backup.PullCompactionRequest)
	+ // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupRequest)
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- // string userId = 1;
	- if (this->userid().size() > 0) {
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	- this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	- "backup.PullCompactionRequest.userId");
	- target = stream->WriteStringMaybeAliased(
	- 1, this->_internal_userid(), target);
	- }
	-
	- // bytes message = 2;
	- if (this->message().size() > 0) {
	- target = stream->WriteBytesMaybeAliased(
	- 2, this->_internal_message(), target);
	+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
	+ if (this->has_authenticationdata()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 1, _Internal::authenticationdata(this), target, stream);
	}

	if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	}
	- // @@protoc_insertion_point(serialize_to_array_end:backup.PullCompactionRequest)
	+ // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupRequest)
	return target;
	}

	-size_t PullCompactionRequest::ByteSizeLong() const {
	-// @@protoc_insertion_point(message_byte_size_start:backup.PullCompactionRequest)
	+size_t PullBackupRequest::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupRequest)
	size_t total_size = 0;

	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- // string userId = 1;
	- if (this->userid().size() > 0) {
	- total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	- this->_internal_userid());
	- }
	-
	- // bytes message = 2;
	- if (this->message().size() > 0) {
	+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
	+ if (this->has_authenticationdata()) {
	total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	- this->_internal_message());
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *authenticationdata_);
	}

	if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	@@ -1337,79 +3207,75 @@
	return total_size;
	}

	-void PullCompactionRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullCompactionRequest)
	+void PullBackupRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupRequest)
	GOOGLE_DCHECK_NE(&from, this);
	- const PullCompactionRequest* source =
	- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullCompactionRequest>(
	+ const PullBackupRequest* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupRequest>(
	&from);
	if (source == nullptr) {
	- // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullCompactionRequest)
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupRequest)
	::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	} else {
	- // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullCompactionRequest)
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupRequest)
	MergeFrom(*source);
	}
	}

	-void PullCompactionRequest::MergeFrom(const PullCompactionRequest& from) {
	-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullCompactionRequest)
	+void PullBackupRequest::MergeFrom(const PullBackupRequest& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupRequest)
	GOOGLE_DCHECK_NE(&from, this);
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- if (from.userid().size() > 0) {
	- _internal_set_userid(from._internal_userid());
	- }
	- if (from.message().size() > 0) {
	- _internal_set_message(from._internal_message());
	+ if (from.has_authenticationdata()) {
	+ _internal_mutable_authenticationdata()->::backup::SimpleAuthenticationRequestData::MergeFrom(from._internal_authenticationdata());
	}
	}

	-void PullCompactionRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullCompactionRequest)
	+void PullBackupRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupRequest)
	if (&from == this) return;
	Clear();
	MergeFrom(from);
	}

	-void PullCompactionRequest::CopyFrom(const PullCompactionRequest& from) {
	-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullCompactionRequest)
	+void PullBackupRequest::CopyFrom(const PullBackupRequest& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupRequest)
	if (&from == this) return;
	Clear();
	MergeFrom(from);
	}

	-bool PullCompactionRequest::IsInitialized() const {
	+bool PullBackupRequest::IsInitialized() const {
	return true;
	}

	-void PullCompactionRequest::InternalSwap(PullCompactionRequest* other) {
	+void PullBackupRequest::InternalSwap(PullBackupRequest* other) {
	using std::swap;
	_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	- message_.Swap(&other->message_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ swap(authenticationdata_, other->authenticationdata_);
	}

	-::PROTOBUF_NAMESPACE_ID::Metadata PullCompactionRequest::GetMetadata() const {
	+::PROTOBUF_NAMESPACE_ID::Metadata PullBackupRequest::GetMetadata() const {
	return GetMetadataStatic();
	}


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

	-class PullCompactionResponse::_Internal {
	+class PullBackupResponse::_Internal {
	public:
	};

	-PullCompactionResponse::PullCompactionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+PullBackupResponse::PullBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	SharedCtor();
	RegisterArenaDtor(arena);
	- // @@protoc_insertion_point(arena_constructor:backup.PullCompactionResponse)
	+ // @@protoc_insertion_point(arena_constructor:backup.PullBackupResponse)
	}
	-PullCompactionResponse::PullCompactionResponse(const PullCompactionResponse& from)
	+PullBackupResponse::PullBackupResponse(const PullBackupResponse& from)
	: ::PROTOBUF_NAMESPACE_ID::Message() {
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	clear_has_data();
	@@ -1426,38 +3292,38 @@
	break;
	}
	}
	- // @@protoc_insertion_point(copy_constructor:backup.PullCompactionResponse)
	+ // @@protoc_insertion_point(copy_constructor:backup.PullBackupResponse)
	}

	-void PullCompactionResponse::SharedCtor() {
	+void PullBackupResponse::SharedCtor() {
	clear_has_data();
	}

	-PullCompactionResponse::~PullCompactionResponse() {
	- // @@protoc_insertion_point(destructor:backup.PullCompactionResponse)
	+PullBackupResponse::~PullBackupResponse() {
	+ // @@protoc_insertion_point(destructor:backup.PullBackupResponse)
	SharedDtor();
	_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	-void PullCompactionResponse::SharedDtor() {
	+void PullBackupResponse::SharedDtor() {
	GOOGLE_DCHECK(GetArena() == nullptr);
	if (has_data()) {
	clear_data();
	}
	}

	-void PullCompactionResponse::ArenaDtor(void* object) {
	- PullCompactionResponse* _this = reinterpret_cast< PullCompactionResponse* >(object);
	+void PullBackupResponse::ArenaDtor(void* object) {
	+ PullBackupResponse* _this = reinterpret_cast< PullBackupResponse* >(object);
	(void)_this;
	}
	-void PullCompactionResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+void PullBackupResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	}
	-void PullCompactionResponse::SetCachedSize(int size) const {
	+void PullBackupResponse::SetCachedSize(int size) const {
	_cached_size_.Set(size);
	}

	-void PullCompactionResponse::clear_data() {
	-// @@protoc_insertion_point(one_of_clear_start:backup.PullCompactionResponse)
	+void PullBackupResponse::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:backup.PullBackupResponse)
	switch (data_case()) {
	case kCompactionChunk: {
	data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	@@ -1475,8 +3341,8 @@
	}


	-void PullCompactionResponse::Clear() {
	-// @@protoc_insertion_point(message_clear_start:backup.PullCompactionResponse)
	+void PullBackupResponse::Clear() {
	+// @@protoc_insertion_point(message_clear_start:backup.PullBackupResponse)
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;
	@@ -1485,7 +3351,7 @@
	_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}

	-const char* PullCompactionResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+const char* PullBackupResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	while (!ctx->Done(&ptr)) {
	::PROTOBUF_NAMESPACE_ID::uint32 tag;
	@@ -1530,9 +3396,9 @@
	#undef CHK_
	}

	-::PROTOBUF_NAMESPACE_ID::uint8* PullCompactionResponse::_InternalSerialize(
	+::PROTOBUF_NAMESPACE_ID::uint8* PullBackupResponse::_InternalSerialize(
	::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	- // @@protoc_insertion_point(serialize_to_array_start:backup.PullCompactionResponse)
	+ // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupResponse)
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	@@ -1552,12 +3418,12 @@
	target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	}
	- // @@protoc_insertion_point(serialize_to_array_end:backup.PullCompactionResponse)
	+ // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupResponse)
	return target;
	}

	-size_t PullCompactionResponse::ByteSizeLong() const {
	-// @@protoc_insertion_point(message_byte_size_start:backup.PullCompactionResponse)
	+size_t PullBackupResponse::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupResponse)
	size_t total_size = 0;

	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	@@ -1592,23 +3458,23 @@
	return total_size;
	}

	-void PullCompactionResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullCompactionResponse)
	+void PullBackupResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupResponse)
	GOOGLE_DCHECK_NE(&from, this);
	- const PullCompactionResponse* source =
	- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullCompactionResponse>(
	+ const PullBackupResponse* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupResponse>(
	&from);
	if (source == nullptr) {
	- // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullCompactionResponse)
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupResponse)
	::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	} else {
	- // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullCompactionResponse)
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupResponse)
	MergeFrom(*source);
	}
	}

	-void PullCompactionResponse::MergeFrom(const PullCompactionResponse& from) {
	-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullCompactionResponse)
	+void PullBackupResponse::MergeFrom(const PullBackupResponse& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupResponse)
	GOOGLE_DCHECK_NE(&from, this);
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	@@ -1629,32 +3495,32 @@
	}
	}

	-void PullCompactionResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullCompactionResponse)
	+void PullBackupResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupResponse)
	if (&from == this) return;
	Clear();
	MergeFrom(from);
	}

	-void PullCompactionResponse::CopyFrom(const PullCompactionResponse& from) {
	-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullCompactionResponse)
	+void PullBackupResponse::CopyFrom(const PullBackupResponse& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupResponse)
	if (&from == this) return;
	Clear();
	MergeFrom(from);
	}

	-bool PullCompactionResponse::IsInitialized() const {
	+bool PullBackupResponse::IsInitialized() const {
	return true;
	}

	-void PullCompactionResponse::InternalSwap(PullCompactionResponse* other) {
	+void PullBackupResponse::InternalSwap(PullBackupResponse* other) {
	using std::swap;
	_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	swap(data_, other->data_);
	swap(_oneof_case_[0], other->_oneof_case_[0]);
	}

	-::PROTOBUF_NAMESPACE_ID::Metadata PullCompactionResponse::GetMetadata() const {
	+::PROTOBUF_NAMESPACE_ID::Metadata PullBackupResponse::GetMetadata() const {
	return GetMetadataStatic();
	}

	@@ -1662,23 +3528,38 @@
	// @@protoc_insertion_point(namespace_scope)
	} // namespace backup
	PROTOBUF_NAMESPACE_OPEN
	-template<> PROTOBUF_NOINLINE ::backup::ResetKeyRequest* Arena::CreateMaybeMessage< ::backup::ResetKeyRequest >(Arena* arena) {
	- return Arena::CreateMessageInternal< ::backup::ResetKeyRequest >(arena);
	+template<> PROTOBUF_NOINLINE ::backup::FullAuthenticationRequestData* Arena::CreateMaybeMessage< ::backup::FullAuthenticationRequestData >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::backup::FullAuthenticationRequestData >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::backup::FullAuthenticationResponseData* Arena::CreateMaybeMessage< ::backup::FullAuthenticationResponseData >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::backup::FullAuthenticationResponseData >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::backup::SimpleAuthenticationRequestData* Arena::CreateMaybeMessage< ::backup::SimpleAuthenticationRequestData >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::backup::SimpleAuthenticationRequestData >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::backup::AuthenticationInformationData* Arena::CreateMaybeMessage< ::backup::AuthenticationInformationData >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::backup::AuthenticationInformationData >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage< ::backup::CreateNewBackupRequest >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::backup::CreateNewBackupRequest >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage< ::backup::CreateNewBackupResponse >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::backup::CreateNewBackupResponse >(arena);
	}
	template<> PROTOBUF_NOINLINE ::backup::SendLogRequest* Arena::CreateMaybeMessage< ::backup::SendLogRequest >(Arena* arena) {
	return Arena::CreateMessageInternal< ::backup::SendLogRequest >(arena);
	}
	-template<> PROTOBUF_NOINLINE ::backup::PullBackupKeyRequest* Arena::CreateMaybeMessage< ::backup::PullBackupKeyRequest >(Arena* arena) {
	- return Arena::CreateMessageInternal< ::backup::PullBackupKeyRequest >(arena);
	+template<> PROTOBUF_NOINLINE ::backup::RecoverBackupKeyRequest* Arena::CreateMaybeMessage< ::backup::RecoverBackupKeyRequest >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::backup::RecoverBackupKeyRequest >(arena);
	}
	-template<> PROTOBUF_NOINLINE ::backup::PullBackupKeyResponse* Arena::CreateMaybeMessage< ::backup::PullBackupKeyResponse >(Arena* arena) {
	- return Arena::CreateMessageInternal< ::backup::PullBackupKeyResponse >(arena);
	+template<> PROTOBUF_NOINLINE ::backup::RecoverBackupKeyResponse* Arena::CreateMaybeMessage< ::backup::RecoverBackupKeyResponse >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::backup::RecoverBackupKeyResponse >(arena);
	}
	-template<> PROTOBUF_NOINLINE ::backup::PullCompactionRequest* Arena::CreateMaybeMessage< ::backup::PullCompactionRequest >(Arena* arena) {
	- return Arena::CreateMessageInternal< ::backup::PullCompactionRequest >(arena);
	+template<> PROTOBUF_NOINLINE ::backup::PullBackupRequest* Arena::CreateMaybeMessage< ::backup::PullBackupRequest >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::backup::PullBackupRequest >(arena);
	}
	-template<> PROTOBUF_NOINLINE ::backup::PullCompactionResponse* Arena::CreateMaybeMessage< ::backup::PullCompactionResponse >(Arena* arena) {
	- return Arena::CreateMessageInternal< ::backup::PullCompactionResponse >(arena);
	+template<> PROTOBUF_NOINLINE ::backup::PullBackupResponse* Arena::CreateMaybeMessage< ::backup::PullBackupResponse >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::backup::PullBackupResponse >(arena);
	}
	PROTOBUF_NAMESPACE_CLOSE

	diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h
	--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h
	+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h
	@@ -92,6 +92,16 @@
	std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) {
	return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>>(PrepareAsyncGetRaw(context, request, cq));
	}
	+ // Replacing Send and Get with a single bidirectional streaming RPC
	+ std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> OpenStream(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(OpenStreamRaw(context));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> AsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(AsyncOpenStreamRaw(context, cq, tag));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> PrepareAsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(PrepareAsyncOpenStreamRaw(context, cq));
	+ }
	class async_interface {
	public:
	virtual ~async_interface() {}
	@@ -114,6 +124,8 @@
	virtual void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) = 0;
	virtual void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0;
	virtual void Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ClientReadReactor< ::tunnelbroker::GetResponse>* reactor) = 0;
	+ // Replacing Send and Get with a single bidirectional streaming RPC
	+ virtual void OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) = 0;
	};
	typedef class async_interface experimental_async_interface;
	virtual class async_interface* async() { return nullptr; }
	@@ -134,6 +146,9 @@
	virtual ::grpc::ClientReaderInterface< ::tunnelbroker::GetResponse>* GetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) = 0;
	virtual ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0;
	virtual ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) = 0;
	+ virtual ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStreamRaw(::grpc::ClientContext* context) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
	};
	class Stub final : public StubInterface {
	public:
	@@ -189,6 +204,15 @@
	std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) {
	return std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>>(PrepareAsyncGetRaw(context, request, cq));
	}
	+ std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> OpenStream(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(OpenStreamRaw(context));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> AsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(AsyncOpenStreamRaw(context, cq, tag));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> PrepareAsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(PrepareAsyncOpenStreamRaw(context, cq));
	+ }
	class async final :
	public StubInterface::async_interface {
	public:
	@@ -205,6 +229,7 @@
	void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) override;
	void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override;
	void Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ClientReadReactor< ::tunnelbroker::GetResponse>* reactor) override;
	+ void OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) override;
	private:
	friend class Stub;
	explicit async(Stub* stub): stub_(stub) { }
	@@ -231,6 +256,9 @@
	::grpc::ClientReader< ::tunnelbroker::GetResponse>* GetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) override;
	::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) override;
	::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) override;
	+ ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStreamRaw(::grpc::ClientContext* context) override;
	+ ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
	+ ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
	const ::grpc::internal::RpcMethod rpcmethod_CheckIfPrimaryDeviceOnline_;
	const ::grpc::internal::RpcMethod rpcmethod_BecomeNewPrimaryDevice_;
	const ::grpc::internal::RpcMethod rpcmethod_SendPong_;
	@@ -238,6 +266,7 @@
	const ::grpc::internal::RpcMethod rpcmethod_NewSession_;
	const ::grpc::internal::RpcMethod rpcmethod_Send_;
	const ::grpc::internal::RpcMethod rpcmethod_Get_;
	+ const ::grpc::internal::RpcMethod rpcmethod_OpenStream_;
	};
	static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());

	@@ -258,6 +287,8 @@
	virtual ::grpc::Status NewSession(::grpc::ServerContext* context, const ::tunnelbroker::NewSessionRequest* request, ::tunnelbroker::NewSessionResponse* response);
	virtual ::grpc::Status Send(::grpc::ServerContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response);
	virtual ::grpc::Status Get(::grpc::ServerContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* writer);
	+ // Replacing Send and Get with a single bidirectional streaming RPC
	+ virtual ::grpc::Status OpenStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream);
	};
	template <class BaseClass>
	class WithAsyncMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
	@@ -399,7 +430,27 @@
	::grpc::Service::RequestAsyncServerStreaming(6, context, request, writer, new_call_cq, notification_cq, tag);
	}
	};
	- typedef WithAsyncMethod_CheckIfPrimaryDeviceOnline<WithAsyncMethod_BecomeNewPrimaryDevice<WithAsyncMethod_SendPong<WithAsyncMethod_SessionSignature<WithAsyncMethod_NewSession<WithAsyncMethod_Send<WithAsyncMethod_Get<Service > > > > > > > AsyncService;
	+ template <class BaseClass>
	+ class WithAsyncMethod_OpenStream : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithAsyncMethod_OpenStream() {
	+ ::grpc::Service::MarkMethodAsync(7);
	+ }
	+ ~WithAsyncMethod_OpenStream() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status OpenStream(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ void RequestOpenStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag);
	+ }
	+ };
	+ typedef WithAsyncMethod_CheckIfPrimaryDeviceOnline<WithAsyncMethod_BecomeNewPrimaryDevice<WithAsyncMethod_SendPong<WithAsyncMethod_SessionSignature<WithAsyncMethod_NewSession<WithAsyncMethod_Send<WithAsyncMethod_Get<WithAsyncMethod_OpenStream<Service > > > > > > > > AsyncService;
	template <class BaseClass>
	class WithCallbackMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
	private:
	@@ -584,7 +635,30 @@
	virtual ::grpc::ServerWriteReactor< ::tunnelbroker::GetResponse>* Get(
	::grpc::CallbackServerContext* /context/, const ::tunnelbroker::GetRequest* /request/) { return nullptr; }
	};
	- typedef WithCallbackMethod_CheckIfPrimaryDeviceOnline<WithCallbackMethod_BecomeNewPrimaryDevice<WithCallbackMethod_SendPong<WithCallbackMethod_SessionSignature<WithCallbackMethod_NewSession<WithCallbackMethod_Send<WithCallbackMethod_Get<Service > > > > > > > CallbackService;
	+ template <class BaseClass>
	+ class WithCallbackMethod_OpenStream : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithCallbackMethod_OpenStream() {
	+ ::grpc::Service::MarkMethodCallback(7,
	+ new ::grpc::internal::CallbackBidiHandler< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>(
	+ [this](
	+ ::grpc::CallbackServerContext* context) { return this->OpenStream(context); }));
	+ }
	+ ~WithCallbackMethod_OpenStream() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status OpenStream(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ virtual ::grpc::ServerBidiReactor< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStream(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	+ };
	+ typedef WithCallbackMethod_CheckIfPrimaryDeviceOnline<WithCallbackMethod_BecomeNewPrimaryDevice<WithCallbackMethod_SendPong<WithCallbackMethod_SessionSignature<WithCallbackMethod_NewSession<WithCallbackMethod_Send<WithCallbackMethod_Get<WithCallbackMethod_OpenStream<Service > > > > > > > > CallbackService;
	typedef CallbackService ExperimentalCallbackService;
	template <class BaseClass>
	class WithGenericMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
	@@ -706,6 +780,23 @@
	}
	};
	template <class BaseClass>
	+ class WithGenericMethod_OpenStream : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithGenericMethod_OpenStream() {
	+ ::grpc::Service::MarkMethodGeneric(7);
	+ }
	+ ~WithGenericMethod_OpenStream() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status OpenStream(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ };
	+ template <class BaseClass>
	class WithRawMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	@@ -846,6 +937,26 @@
	}
	};
	template <class BaseClass>
	+ class WithRawMethod_OpenStream : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithRawMethod_OpenStream() {
	+ ::grpc::Service::MarkMethodRaw(7);
	+ }
	+ ~WithRawMethod_OpenStream() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status OpenStream(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ void RequestOpenStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag);
	+ }
	+ };
	+ template <class BaseClass>
	class WithRawCallbackMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	@@ -1000,6 +1111,29 @@
	::grpc::CallbackServerContext* /context/, const ::grpc::ByteBuffer* /request/) { return nullptr; }
	};
	template <class BaseClass>
	+ class WithRawCallbackMethod_OpenStream : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithRawCallbackMethod_OpenStream() {
	+ ::grpc::Service::MarkMethodRawCallback(7,
	+ new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	+ [this](
	+ ::grpc::CallbackServerContext* context) { return this->OpenStream(context); }));
	+ }
	+ ~WithRawCallbackMethod_OpenStream() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status OpenStream(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* OpenStream(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	+ };
	+ template <class BaseClass>
	class WithStreamedUnaryMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
	private:
	void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc
	--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc
	+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc
	@@ -29,6 +29,7 @@
	"/tunnelbroker.TunnelbrokerService/NewSession",
	"/tunnelbroker.TunnelbrokerService/Send",
	"/tunnelbroker.TunnelbrokerService/Get",
	+ "/tunnelbroker.TunnelbrokerService/OpenStream",
	};

	std::unique_ptr< TunnelbrokerService::Stub> TunnelbrokerService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
	@@ -45,6 +46,7 @@
	, rpcmethod_NewSession_(TunnelbrokerService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
	, rpcmethod_Send_(TunnelbrokerService_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
	, rpcmethod_Get_(TunnelbrokerService_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
	+ , rpcmethod_OpenStream_(TunnelbrokerService_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
	{}

	::grpc::Status TunnelbrokerService::Stub::CheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::tunnelbroker::CheckResponse* response) {
	@@ -201,6 +203,22 @@
	return ::grpc::internal::ClientAsyncReaderFactory< ::tunnelbroker::GetResponse>::Create(channel_.get(), cq, rpcmethod_Get_, context, request, false, nullptr);
	}

	+::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::OpenStreamRaw(::grpc::ClientContext* context) {
	+ return ::grpc::internal::ClientReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), rpcmethod_OpenStream_, context);
	+}
	+
	+void TunnelbrokerService::Stub::async::OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) {
	+ ::grpc::internal::ClientCallbackReaderWriterFactory< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>::Create(stub_->channel_.get(), stub_->rpcmethod_OpenStream_, context, reactor);
	+}
	+
	+::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), cq, rpcmethod_OpenStream_, context, true, tag);
	+}
	+
	+::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), cq, rpcmethod_OpenStream_, context, false, nullptr);
	+}
	+
	TunnelbrokerService::Service::Service() {
	AddMethod(new ::grpc::internal::RpcServiceMethod(
	TunnelbrokerService_method_names[0],
	@@ -272,6 +290,16 @@
	::grpc::ServerWriter<::tunnelbroker::GetResponse>* writer) {
	return service->Get(ctx, req, writer);
	}, this)));
	+ AddMethod(new ::grpc::internal::RpcServiceMethod(
	+ TunnelbrokerService_method_names[7],
	+ ::grpc::internal::RpcMethod::BIDI_STREAMING,
	+ new ::grpc::internal::BidiStreamingHandler< TunnelbrokerService::Service, ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>(
	+ [](TunnelbrokerService::Service* service,
	+ ::grpc::ServerContext* ctx,
	+ ::grpc::ServerReaderWriter<::tunnelbroker::InboundMessage,
	+ ::tunnelbroker::OutboundMessage>* stream) {
	+ return service->OpenStream(ctx, stream);
	+ }, this)));
	}

	TunnelbrokerService::Service::~Service() {
	@@ -326,6 +354,12 @@
	return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	}

	+::grpc::Status TunnelbrokerService::Service::OpenStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream) {
	+ (void) context;
	+ (void) stream;
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+}
	+

	} // namespace tunnelbroker

	diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h
	--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h
	+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h
	@@ -48,7 +48,7 @@
	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[12]
	+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14]
	PROTOBUF_SECTION_VARIABLE(protodesc_cold);
	static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
	static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
	@@ -69,6 +69,9 @@
	class GetResponse;
	struct GetResponseDefaultTypeInternal;
	extern GetResponseDefaultTypeInternal _GetResponse_default_instance_;
	+class InboundMessage;
	+struct InboundMessageDefaultTypeInternal;
	+extern InboundMessageDefaultTypeInternal _InboundMessage_default_instance_;
	class NewPrimaryRequest;
	struct NewPrimaryRequestDefaultTypeInternal;
	extern NewPrimaryRequestDefaultTypeInternal _NewPrimaryRequest_default_instance_;
	@@ -81,6 +84,9 @@
	class NewSessionResponse;
	struct NewSessionResponseDefaultTypeInternal;
	extern NewSessionResponseDefaultTypeInternal _NewSessionResponse_default_instance_;
	+class OutboundMessage;
	+struct OutboundMessageDefaultTypeInternal;
	+extern OutboundMessageDefaultTypeInternal _OutboundMessage_default_instance_;
	class PongRequest;
	struct PongRequestDefaultTypeInternal;
	extern PongRequestDefaultTypeInternal _PongRequest_default_instance_;
	@@ -99,10 +105,12 @@
	template<> ::tunnelbroker::CheckResponse* Arena::CreateMaybeMessage<::tunnelbroker::CheckResponse>(Arena*);
	template<> ::tunnelbroker::GetRequest* Arena::CreateMaybeMessage<::tunnelbroker::GetRequest>(Arena*);
	template<> ::tunnelbroker::GetResponse* Arena::CreateMaybeMessage<::tunnelbroker::GetResponse>(Arena*);
	+template<> ::tunnelbroker::InboundMessage* Arena::CreateMaybeMessage<::tunnelbroker::InboundMessage>(Arena*);
	template<> ::tunnelbroker::NewPrimaryRequest* Arena::CreateMaybeMessage<::tunnelbroker::NewPrimaryRequest>(Arena*);
	template<> ::tunnelbroker::NewPrimaryResponse* Arena::CreateMaybeMessage<::tunnelbroker::NewPrimaryResponse>(Arena*);
	template<> ::tunnelbroker::NewSessionRequest* Arena::CreateMaybeMessage<::tunnelbroker::NewSessionRequest>(Arena*);
	template<> ::tunnelbroker::NewSessionResponse* Arena::CreateMaybeMessage<::tunnelbroker::NewSessionResponse>(Arena*);
	+template<> ::tunnelbroker::OutboundMessage* Arena::CreateMaybeMessage<::tunnelbroker::OutboundMessage>(Arena*);
	template<> ::tunnelbroker::PongRequest* Arena::CreateMaybeMessage<::tunnelbroker::PongRequest>(Arena*);
	template<> ::tunnelbroker::SendRequest* Arena::CreateMaybeMessage<::tunnelbroker::SendRequest>(Arena*);
	template<> ::tunnelbroker::SessionSignatureRequest* Arena::CreateMaybeMessage<::tunnelbroker::SessionSignatureRequest>(Arena*);
	@@ -622,13 +630,13 @@
	std::string* _internal_mutable_deviceid();
	public:

	- // bytes publicKey = 2;
	+ // string publicKey = 2;
	void clear_publickey();
	const std::string& publickey() const;
	void set_publickey(const std::string& value);
	void set_publickey(std::string&& value);
	void set_publickey(const char* value);
	- void set_publickey(const void* value, size_t size);
	+ void set_publickey(const char* value, size_t size);
	std::string* mutable_publickey();
	std::string* release_publickey();
	void set_allocated_publickey(std::string* publickey);
	@@ -1417,24 +1425,24 @@
	};
	// -------------------------------------------------------------------

	-class CheckRequest PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckRequest) */ {
	+class OutboundMessage PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.OutboundMessage) */ {
	public:
	- inline CheckRequest() : CheckRequest(nullptr) {}
	- virtual ~CheckRequest();
	- explicit constexpr CheckRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline OutboundMessage() : OutboundMessage(nullptr) {}
	+ virtual ~OutboundMessage();
	+ explicit constexpr OutboundMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- CheckRequest(const CheckRequest& from);
	- CheckRequest(CheckRequest&& from) noexcept
	- : CheckRequest() {
	+ OutboundMessage(const OutboundMessage& from);
	+ OutboundMessage(OutboundMessage&& from) noexcept
	+ : OutboundMessage() {
	*this = ::std::move(from);
	}

	- inline CheckRequest& operator=(const CheckRequest& from) {
	+ inline OutboundMessage& operator=(const OutboundMessage& from) {
	CopyFrom(from);
	return *this;
	}
	- inline CheckRequest& operator=(CheckRequest&& from) noexcept {
	+ inline OutboundMessage& operator=(OutboundMessage&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -1452,20 +1460,20 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const CheckRequest& default_instance() {
	+ static const OutboundMessage& default_instance() {
	return *internal_default_instance();
	}
	- static inline const CheckRequest* internal_default_instance() {
	- return reinterpret_cast<const CheckRequest*>(
	- &_CheckRequest_default_instance_);
	+ static inline const OutboundMessage* internal_default_instance() {
	+ return reinterpret_cast<const OutboundMessage*>(
	+ &_OutboundMessage_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	7;

	- friend void swap(CheckRequest& a, CheckRequest& b) {
	+ friend void swap(OutboundMessage& a, OutboundMessage& b) {
	a.Swap(&b);
	}
	- inline void Swap(CheckRequest* other) {
	+ inline void Swap(OutboundMessage* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -1473,7 +1481,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(CheckRequest* other) {
	+ void UnsafeArenaSwap(OutboundMessage* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -1481,17 +1489,17 @@

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

	- inline CheckRequest* New() const final {
	- return CreateMaybeMessage<CheckRequest>(nullptr);
	+ inline OutboundMessage* New() const final {
	+ return CreateMaybeMessage<OutboundMessage>(nullptr);
	}

	- CheckRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<CheckRequest>(arena);
	+ OutboundMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<OutboundMessage>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const CheckRequest& from);
	- void MergeFrom(const CheckRequest& from);
	+ void CopyFrom(const OutboundMessage& from);
	+ void MergeFrom(const OutboundMessage& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -1505,13 +1513,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(CheckRequest* other);
	+ void InternalSwap(OutboundMessage* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "tunnelbroker.CheckRequest";
	+ return "tunnelbroker.OutboundMessage";
	}
	protected:
	- explicit CheckRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit OutboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -1530,73 +1538,99 @@
	// accessors -------------------------------------------------------

	enum : int {
	- kUserIdFieldNumber = 1,
	- kDeviceTokenFieldNumber = 2,
	+ kBlobHashesFieldNumber = 3,
	+ kToDeviceIDFieldNumber = 1,
	+ kPayloadFieldNumber = 2,
	};
	- // string userId = 1;
	- void clear_userid();
	- const std::string& userid() const;
	- void set_userid(const std::string& value);
	- void set_userid(std::string&& value);
	- void set_userid(const char* value);
	- void set_userid(const char* value, size_t size);
	- std::string* mutable_userid();
	- std::string* release_userid();
	- void set_allocated_userid(std::string* userid);
	+ // repeated string blobHashes = 3;
	+ int blobhashes_size() const;
	private:
	- const std::string& _internal_userid() const;
	- void _internal_set_userid(const std::string& value);
	- std::string* _internal_mutable_userid();
	+ int _internal_blobhashes_size() const;
	+ public:
	+ void clear_blobhashes();
	+ const std::string& blobhashes(int index) const;
	+ std::string* mutable_blobhashes(int index);
	+ void set_blobhashes(int index, const std::string& value);
	+ void set_blobhashes(int index, std::string&& value);
	+ void set_blobhashes(int index, const char* value);
	+ void set_blobhashes(int index, const char* value, size_t size);
	+ std::string* add_blobhashes();
	+ void add_blobhashes(const std::string& value);
	+ void add_blobhashes(std::string&& value);
	+ void add_blobhashes(const char* value);
	+ void add_blobhashes(const char* value, size_t size);
	+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& blobhashes() const;
	+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_blobhashes();
	+ private:
	+ const std::string& _internal_blobhashes(int index) const;
	+ std::string* _internal_add_blobhashes();
	public:

	- // string deviceToken = 2;
	- void clear_devicetoken();
	- const std::string& devicetoken() const;
	- void set_devicetoken(const std::string& value);
	- void set_devicetoken(std::string&& value);
	- void set_devicetoken(const char* value);
	- void set_devicetoken(const char* value, size_t size);
	- std::string* mutable_devicetoken();
	- std::string* release_devicetoken();
	- void set_allocated_devicetoken(std::string* devicetoken);
	+ // string toDeviceID = 1;
	+ void clear_todeviceid();
	+ const std::string& todeviceid() const;
	+ void set_todeviceid(const std::string& value);
	+ void set_todeviceid(std::string&& value);
	+ void set_todeviceid(const char* value);
	+ void set_todeviceid(const char* value, size_t size);
	+ std::string* mutable_todeviceid();
	+ std::string* release_todeviceid();
	+ void set_allocated_todeviceid(std::string* todeviceid);
	private:
	- const std::string& _internal_devicetoken() const;
	- void _internal_set_devicetoken(const std::string& value);
	- std::string* _internal_mutable_devicetoken();
	+ const std::string& _internal_todeviceid() const;
	+ void _internal_set_todeviceid(const std::string& value);
	+ std::string* _internal_mutable_todeviceid();
	public:

	- // @@protoc_insertion_point(class_scope:tunnelbroker.CheckRequest)
	+ // string payload = 2;
	+ void clear_payload();
	+ const std::string& payload() const;
	+ void set_payload(const std::string& value);
	+ void set_payload(std::string&& value);
	+ void set_payload(const char* value);
	+ void set_payload(const char* value, size_t size);
	+ std::string* mutable_payload();
	+ std::string* release_payload();
	+ void set_allocated_payload(std::string* payload);
	+ private:
	+ const std::string& _internal_payload() const;
	+ void _internal_set_payload(const std::string& value);
	+ std::string* _internal_mutable_payload();
	+ public:
	+
	+ // @@protoc_insertion_point(class_scope:tunnelbroker.OutboundMessage)
	private:
	class _Internal;

	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	typedef void InternalArenaConstructable_;
	typedef void DestructorSkippable_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicetoken_;
	+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> blobhashes_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr todeviceid_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	friend struct ::TableStruct_tunnelbroker_2eproto;
	};
	// -------------------------------------------------------------------

	-class CheckResponse PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckResponse) */ {
	+class InboundMessage PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.InboundMessage) */ {
	public:
	- inline CheckResponse() : CheckResponse(nullptr) {}
	- virtual ~CheckResponse();
	- explicit constexpr CheckResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline InboundMessage() : InboundMessage(nullptr) {}
	+ virtual ~InboundMessage();
	+ explicit constexpr InboundMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- CheckResponse(const CheckResponse& from);
	- CheckResponse(CheckResponse&& from) noexcept
	- : CheckResponse() {
	+ InboundMessage(const InboundMessage& from);
	+ InboundMessage(InboundMessage&& from) noexcept
	+ : InboundMessage() {
	*this = ::std::move(from);
	}

	- inline CheckResponse& operator=(const CheckResponse& from) {
	+ inline InboundMessage& operator=(const InboundMessage& from) {
	CopyFrom(from);
	return *this;
	}
	- inline CheckResponse& operator=(CheckResponse&& from) noexcept {
	+ inline InboundMessage& operator=(InboundMessage&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -1614,20 +1648,20 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const CheckResponse& default_instance() {
	+ static const InboundMessage& default_instance() {
	return *internal_default_instance();
	}
	- static inline const CheckResponse* internal_default_instance() {
	- return reinterpret_cast<const CheckResponse*>(
	- &_CheckResponse_default_instance_);
	+ static inline const InboundMessage* internal_default_instance() {
	+ return reinterpret_cast<const InboundMessage*>(
	+ &_InboundMessage_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	8;

	- friend void swap(CheckResponse& a, CheckResponse& b) {
	+ friend void swap(InboundMessage& a, InboundMessage& b) {
	a.Swap(&b);
	}
	- inline void Swap(CheckResponse* other) {
	+ inline void Swap(InboundMessage* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -1635,7 +1669,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(CheckResponse* other) {
	+ void UnsafeArenaSwap(InboundMessage* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -1643,17 +1677,17 @@

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

	- inline CheckResponse* New() const final {
	- return CreateMaybeMessage<CheckResponse>(nullptr);
	+ inline InboundMessage* New() const final {
	+ return CreateMaybeMessage<InboundMessage>(nullptr);
	}

	- CheckResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<CheckResponse>(arena);
	+ InboundMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<InboundMessage>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const CheckResponse& from);
	- void MergeFrom(const CheckResponse& from);
	+ void CopyFrom(const InboundMessage& from);
	+ void MergeFrom(const InboundMessage& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -1667,13 +1701,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(CheckResponse* other);
	+ void InternalSwap(InboundMessage* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "tunnelbroker.CheckResponse";
	+ return "tunnelbroker.InboundMessage";
	}
	protected:
	- explicit CheckResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit InboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -1692,48 +1726,117 @@
	// accessors -------------------------------------------------------

	enum : int {
	- kCheckResponseTypeFieldNumber = 1,
	+ kBlobHashesFieldNumber = 4,
	+ kFromDeviceIDFieldNumber = 1,
	+ kFromConnectionIDFieldNumber = 2,
	+ kPayloadFieldNumber = 3,
	};
	- // .tunnelbroker.CheckResponseType checkResponseType = 1;
	- void clear_checkresponsetype();
	- ::tunnelbroker::CheckResponseType checkresponsetype() const;
	- void set_checkresponsetype(::tunnelbroker::CheckResponseType value);
	+ // repeated string blobHashes = 4;
	+ int blobhashes_size() const;
	private:
	- ::tunnelbroker::CheckResponseType _internal_checkresponsetype() const;
	- void _internal_set_checkresponsetype(::tunnelbroker::CheckResponseType value);
	+ int _internal_blobhashes_size() const;
	+ public:
	+ void clear_blobhashes();
	+ const std::string& blobhashes(int index) const;
	+ std::string* mutable_blobhashes(int index);
	+ void set_blobhashes(int index, const std::string& value);
	+ void set_blobhashes(int index, std::string&& value);
	+ void set_blobhashes(int index, const char* value);
	+ void set_blobhashes(int index, const char* value, size_t size);
	+ std::string* add_blobhashes();
	+ void add_blobhashes(const std::string& value);
	+ void add_blobhashes(std::string&& value);
	+ void add_blobhashes(const char* value);
	+ void add_blobhashes(const char* value, size_t size);
	+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& blobhashes() const;
	+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_blobhashes();
	+ private:
	+ const std::string& _internal_blobhashes(int index) const;
	+ std::string* _internal_add_blobhashes();
	public:

	- // @@protoc_insertion_point(class_scope:tunnelbroker.CheckResponse)
	+ // string fromDeviceID = 1;
	+ void clear_fromdeviceid();
	+ const std::string& fromdeviceid() const;
	+ void set_fromdeviceid(const std::string& value);
	+ void set_fromdeviceid(std::string&& value);
	+ void set_fromdeviceid(const char* value);
	+ void set_fromdeviceid(const char* value, size_t size);
	+ std::string* mutable_fromdeviceid();
	+ std::string* release_fromdeviceid();
	+ void set_allocated_fromdeviceid(std::string* fromdeviceid);
	+ private:
	+ const std::string& _internal_fromdeviceid() const;
	+ void _internal_set_fromdeviceid(const std::string& value);
	+ std::string* _internal_mutable_fromdeviceid();
	+ public:
	+
	+ // string fromConnectionID = 2;
	+ void clear_fromconnectionid();
	+ const std::string& fromconnectionid() const;
	+ void set_fromconnectionid(const std::string& value);
	+ void set_fromconnectionid(std::string&& value);
	+ void set_fromconnectionid(const char* value);
	+ void set_fromconnectionid(const char* value, size_t size);
	+ std::string* mutable_fromconnectionid();
	+ std::string* release_fromconnectionid();
	+ void set_allocated_fromconnectionid(std::string* fromconnectionid);
	+ private:
	+ const std::string& _internal_fromconnectionid() const;
	+ void _internal_set_fromconnectionid(const std::string& value);
	+ std::string* _internal_mutable_fromconnectionid();
	+ public:
	+
	+ // string payload = 3;
	+ void clear_payload();
	+ const std::string& payload() const;
	+ void set_payload(const std::string& value);
	+ void set_payload(std::string&& value);
	+ void set_payload(const char* value);
	+ void set_payload(const char* value, size_t size);
	+ std::string* mutable_payload();
	+ std::string* release_payload();
	+ void set_allocated_payload(std::string* payload);
	+ private:
	+ const std::string& _internal_payload() const;
	+ void _internal_set_payload(const std::string& value);
	+ std::string* _internal_mutable_payload();
	+ public:
	+
	+ // @@protoc_insertion_point(class_scope:tunnelbroker.InboundMessage)
	private:
	class _Internal;

	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	typedef void InternalArenaConstructable_;
	typedef void DestructorSkippable_;
	- int checkresponsetype_;
	+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> blobhashes_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromdeviceid_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromconnectionid_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	friend struct ::TableStruct_tunnelbroker_2eproto;
	};
	// -------------------------------------------------------------------

	-class NewPrimaryRequest PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryRequest) */ {
	+class CheckRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckRequest) */ {
	public:
	- inline NewPrimaryRequest() : NewPrimaryRequest(nullptr) {}
	- virtual ~NewPrimaryRequest();
	- explicit constexpr NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline CheckRequest() : CheckRequest(nullptr) {}
	+ virtual ~CheckRequest();
	+ explicit constexpr CheckRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- NewPrimaryRequest(const NewPrimaryRequest& from);
	- NewPrimaryRequest(NewPrimaryRequest&& from) noexcept
	- : NewPrimaryRequest() {
	+ CheckRequest(const CheckRequest& from);
	+ CheckRequest(CheckRequest&& from) noexcept
	+ : CheckRequest() {
	*this = ::std::move(from);
	}

	- inline NewPrimaryRequest& operator=(const NewPrimaryRequest& from) {
	+ inline CheckRequest& operator=(const CheckRequest& from) {
	CopyFrom(from);
	return *this;
	}
	- inline NewPrimaryRequest& operator=(NewPrimaryRequest&& from) noexcept {
	+ inline CheckRequest& operator=(CheckRequest&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -1751,20 +1854,20 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const NewPrimaryRequest& default_instance() {
	+ static const CheckRequest& default_instance() {
	return *internal_default_instance();
	}
	- static inline const NewPrimaryRequest* internal_default_instance() {
	- return reinterpret_cast<const NewPrimaryRequest*>(
	- &_NewPrimaryRequest_default_instance_);
	+ static inline const CheckRequest* internal_default_instance() {
	+ return reinterpret_cast<const CheckRequest*>(
	+ &_CheckRequest_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	9;

	- friend void swap(NewPrimaryRequest& a, NewPrimaryRequest& b) {
	+ friend void swap(CheckRequest& a, CheckRequest& b) {
	a.Swap(&b);
	}
	- inline void Swap(NewPrimaryRequest* other) {
	+ inline void Swap(CheckRequest* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -1772,7 +1875,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(NewPrimaryRequest* other) {
	+ void UnsafeArenaSwap(CheckRequest* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -1780,17 +1883,17 @@

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

	- inline NewPrimaryRequest* New() const final {
	- return CreateMaybeMessage<NewPrimaryRequest>(nullptr);
	+ inline CheckRequest* New() const final {
	+ return CreateMaybeMessage<CheckRequest>(nullptr);
	}

	- NewPrimaryRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<NewPrimaryRequest>(arena);
	+ CheckRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<CheckRequest>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const NewPrimaryRequest& from);
	- void MergeFrom(const NewPrimaryRequest& from);
	+ void CopyFrom(const CheckRequest& from);
	+ void MergeFrom(const CheckRequest& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -1804,13 +1907,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(NewPrimaryRequest* other);
	+ void InternalSwap(CheckRequest* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "tunnelbroker.NewPrimaryRequest";
	+ return "tunnelbroker.CheckRequest";
	}
	protected:
	- explicit NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit CheckRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -1864,7 +1967,7 @@
	std::string* _internal_mutable_devicetoken();
	public:

	- // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryRequest)
	+ // @@protoc_insertion_point(class_scope:tunnelbroker.CheckRequest)
	private:
	class _Internal;

	@@ -1878,24 +1981,24 @@
	};
	// -------------------------------------------------------------------

	-class NewPrimaryResponse PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryResponse) */ {
	+class CheckResponse PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckResponse) */ {
	public:
	- inline NewPrimaryResponse() : NewPrimaryResponse(nullptr) {}
	- virtual ~NewPrimaryResponse();
	- explicit constexpr NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline CheckResponse() : CheckResponse(nullptr) {}
	+ virtual ~CheckResponse();
	+ explicit constexpr CheckResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- NewPrimaryResponse(const NewPrimaryResponse& from);
	- NewPrimaryResponse(NewPrimaryResponse&& from) noexcept
	- : NewPrimaryResponse() {
	+ CheckResponse(const CheckResponse& from);
	+ CheckResponse(CheckResponse&& from) noexcept
	+ : CheckResponse() {
	*this = ::std::move(from);
	}

	- inline NewPrimaryResponse& operator=(const NewPrimaryResponse& from) {
	+ inline CheckResponse& operator=(const CheckResponse& from) {
	CopyFrom(from);
	return *this;
	}
	- inline NewPrimaryResponse& operator=(NewPrimaryResponse&& from) noexcept {
	+ inline CheckResponse& operator=(CheckResponse&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -1913,20 +2016,20 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const NewPrimaryResponse& default_instance() {
	+ static const CheckResponse& default_instance() {
	return *internal_default_instance();
	}
	- static inline const NewPrimaryResponse* internal_default_instance() {
	- return reinterpret_cast<const NewPrimaryResponse*>(
	- &_NewPrimaryResponse_default_instance_);
	+ static inline const CheckResponse* internal_default_instance() {
	+ return reinterpret_cast<const CheckResponse*>(
	+ &_CheckResponse_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	10;

	- friend void swap(NewPrimaryResponse& a, NewPrimaryResponse& b) {
	+ friend void swap(CheckResponse& a, CheckResponse& b) {
	a.Swap(&b);
	}
	- inline void Swap(NewPrimaryResponse* other) {
	+ inline void Swap(CheckResponse* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -1934,7 +2037,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(NewPrimaryResponse* other) {
	+ void UnsafeArenaSwap(CheckResponse* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -1942,17 +2045,17 @@

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

	- inline NewPrimaryResponse* New() const final {
	- return CreateMaybeMessage<NewPrimaryResponse>(nullptr);
	+ inline CheckResponse* New() const final {
	+ return CreateMaybeMessage<CheckResponse>(nullptr);
	}

	- NewPrimaryResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<NewPrimaryResponse>(arena);
	+ CheckResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<CheckResponse>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const NewPrimaryResponse& from);
	- void MergeFrom(const NewPrimaryResponse& from);
	+ void CopyFrom(const CheckResponse& from);
	+ void MergeFrom(const CheckResponse& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -1966,13 +2069,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(NewPrimaryResponse* other);
	+ void InternalSwap(CheckResponse* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "tunnelbroker.NewPrimaryResponse";
	+ return "tunnelbroker.CheckResponse";
	}
	protected:
	- explicit NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit CheckResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -1991,48 +2094,48 @@
	// accessors -------------------------------------------------------

	enum : int {
	- kSuccessFieldNumber = 1,
	+ kCheckResponseTypeFieldNumber = 1,
	};
	- // bool success = 1;
	- void clear_success();
	- bool success() const;
	- void set_success(bool value);
	+ // .tunnelbroker.CheckResponseType checkResponseType = 1;
	+ void clear_checkresponsetype();
	+ ::tunnelbroker::CheckResponseType checkresponsetype() const;
	+ void set_checkresponsetype(::tunnelbroker::CheckResponseType value);
	private:
	- bool _internal_success() const;
	- void _internal_set_success(bool value);
	+ ::tunnelbroker::CheckResponseType _internal_checkresponsetype() const;
	+ void _internal_set_checkresponsetype(::tunnelbroker::CheckResponseType value);
	public:

	- // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryResponse)
	+ // @@protoc_insertion_point(class_scope:tunnelbroker.CheckResponse)
	private:
	class _Internal;

	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	typedef void InternalArenaConstructable_;
	typedef void DestructorSkippable_;
	- bool success_;
	+ int checkresponsetype_;
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	friend struct ::TableStruct_tunnelbroker_2eproto;
	};
	// -------------------------------------------------------------------

	-class PongRequest PROTOBUF_FINAL :
	- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.PongRequest) */ {
	+class NewPrimaryRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryRequest) */ {
	public:
	- inline PongRequest() : PongRequest(nullptr) {}
	- virtual ~PongRequest();
	- explicit constexpr PongRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+ inline NewPrimaryRequest() : NewPrimaryRequest(nullptr) {}
	+ virtual ~NewPrimaryRequest();
	+ explicit constexpr NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	- PongRequest(const PongRequest& from);
	- PongRequest(PongRequest&& from) noexcept
	- : PongRequest() {
	+ NewPrimaryRequest(const NewPrimaryRequest& from);
	+ NewPrimaryRequest(NewPrimaryRequest&& from) noexcept
	+ : NewPrimaryRequest() {
	*this = ::std::move(from);
	}

	- inline PongRequest& operator=(const PongRequest& from) {
	+ inline NewPrimaryRequest& operator=(const NewPrimaryRequest& from) {
	CopyFrom(from);
	return *this;
	}
	- inline PongRequest& operator=(PongRequest&& from) noexcept {
	+ inline NewPrimaryRequest& operator=(NewPrimaryRequest&& from) noexcept {
	if (GetArena() == from.GetArena()) {
	if (this != &from) InternalSwap(&from);
	} else {
	@@ -2050,20 +2153,20 @@
	static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	return GetMetadataStatic().reflection;
	}
	- static const PongRequest& default_instance() {
	+ static const NewPrimaryRequest& default_instance() {
	return *internal_default_instance();
	}
	- static inline const PongRequest* internal_default_instance() {
	- return reinterpret_cast<const PongRequest*>(
	- &_PongRequest_default_instance_);
	+ static inline const NewPrimaryRequest* internal_default_instance() {
	+ return reinterpret_cast<const NewPrimaryRequest*>(
	+ &_NewPrimaryRequest_default_instance_);
	}
	static constexpr int kIndexInFileMessages =
	11;

	- friend void swap(PongRequest& a, PongRequest& b) {
	+ friend void swap(NewPrimaryRequest& a, NewPrimaryRequest& b) {
	a.Swap(&b);
	}
	- inline void Swap(PongRequest* other) {
	+ inline void Swap(NewPrimaryRequest* other) {
	if (other == this) return;
	if (GetArena() == other->GetArena()) {
	InternalSwap(other);
	@@ -2071,7 +2174,7 @@
	::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	}
	}
	- void UnsafeArenaSwap(PongRequest* other) {
	+ void UnsafeArenaSwap(NewPrimaryRequest* other) {
	if (other == this) return;
	GOOGLE_DCHECK(GetArena() == other->GetArena());
	InternalSwap(other);
	@@ -2079,17 +2182,17 @@

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

	- inline PongRequest* New() const final {
	- return CreateMaybeMessage<PongRequest>(nullptr);
	+ inline NewPrimaryRequest* New() const final {
	+ return CreateMaybeMessage<NewPrimaryRequest>(nullptr);
	}

	- PongRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	- return CreateMaybeMessage<PongRequest>(arena);
	+ NewPrimaryRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<NewPrimaryRequest>(arena);
	}
	void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	- void CopyFrom(const PongRequest& from);
	- void MergeFrom(const PongRequest& from);
	+ void CopyFrom(const NewPrimaryRequest& from);
	+ void MergeFrom(const NewPrimaryRequest& from);
	PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
	bool IsInitialized() const final;

	@@ -2103,13 +2206,13 @@
	inline void SharedCtor();
	inline void SharedDtor();
	void SetCachedSize(int size) const final;
	- void InternalSwap(PongRequest* other);
	+ void InternalSwap(NewPrimaryRequest* other);
	friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	- return "tunnelbroker.PongRequest";
	+ return "tunnelbroker.NewPrimaryRequest";
	}
	protected:
	- explicit PongRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ explicit NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	private:
	static void ArenaDtor(void* object);
	inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	@@ -2163,7 +2266,7 @@
	std::string* _internal_mutable_devicetoken();
	public:

	- // @@protoc_insertion_point(class_scope:tunnelbroker.PongRequest)
	+ // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryRequest)
	private:
	class _Internal;

	@@ -2175,726 +2278,1490 @@
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	friend struct ::TableStruct_tunnelbroker_2eproto;
	};
	-// ===================================================================
	+// -------------------------------------------------------------------

	+class NewPrimaryResponse PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryResponse) */ {
	+ public:
	+ inline NewPrimaryResponse() : NewPrimaryResponse(nullptr) {}
	+ virtual ~NewPrimaryResponse();
	+ explicit constexpr NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

	-// ===================================================================
	+ NewPrimaryResponse(const NewPrimaryResponse& from);
	+ NewPrimaryResponse(NewPrimaryResponse&& from) noexcept
	+ : NewPrimaryResponse() {
	+ *this = ::std::move(from);
	+ }

	-#ifdef __GNUC__
	- #pragma GCC diagnostic push
	- #pragma GCC diagnostic ignored "-Wstrict-aliasing"
	-#endif // __GNUC__
	-// SessionSignatureRequest
	+ inline NewPrimaryResponse& operator=(const NewPrimaryResponse& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline NewPrimaryResponse& operator=(NewPrimaryResponse&& from) noexcept {
	+ if (GetArena() == from.GetArena()) {
	+ if (this != &from) InternalSwap(&from);
	+ } else {
	+ CopyFrom(from);
	+ }
	+ return *this;
	+ }

	-// string deviceID = 1;
	-inline void SessionSignatureRequest::clear_deviceid() {
	- deviceid_.ClearToEmpty();
	-}
	-inline const std::string& SessionSignatureRequest::deviceid() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureRequest.deviceID)
	- return _internal_deviceid();
	-}
	-inline void SessionSignatureRequest::set_deviceid(const std::string& value) {
	- _internal_set_deviceid(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureRequest.deviceID)
	-}
	-inline std::string* SessionSignatureRequest::mutable_deviceid() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureRequest.deviceID)
	- return _internal_mutable_deviceid();
	-}
	-inline const std::string& SessionSignatureRequest::_internal_deviceid() const {
	- return deviceid_.Get();
	-}
	-inline void SessionSignatureRequest::_internal_set_deviceid(const std::string& value) {
	-
	- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	-}
	-inline void SessionSignatureRequest::set_deviceid(std::string&& value) {
	-
	- deviceid_.Set(
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureRequest.deviceID)
	-}
	-inline void SessionSignatureRequest::set_deviceid(const char* value) {
	- GOOGLE_DCHECK(value != nullptr);
	-
	- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureRequest.deviceID)
	-}
	-inline void SessionSignatureRequest::set_deviceid(const char* value,
	- size_t size) {
	-
	- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	- reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureRequest.deviceID)
	-}
	-inline std::string* SessionSignatureRequest::_internal_mutable_deviceid() {
	-
	- return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	-}
	-inline std::string* SessionSignatureRequest::release_deviceid() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureRequest.deviceID)
	- return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	-}
	-inline void SessionSignatureRequest::set_allocated_deviceid(std::string* deviceid) {
	- if (deviceid != nullptr) {
	-
	- } else {
	-
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
	+ return GetDescriptor();
	}
	- deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
	- GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureRequest.deviceID)
	-}
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
	+ return GetMetadataStatic().descriptor;
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	+ return GetMetadataStatic().reflection;
	+ }
	+ static const NewPrimaryResponse& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const NewPrimaryResponse* internal_default_instance() {
	+ return reinterpret_cast<const NewPrimaryResponse*>(
	+ &_NewPrimaryResponse_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 12;

	-// -------------------------------------------------------------------
	+ friend void swap(NewPrimaryResponse& a, NewPrimaryResponse& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(NewPrimaryResponse* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(NewPrimaryResponse* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }

	-// SessionSignatureResponse
	+ // implements Message ----------------------------------------------

	-// string toSign = 1;
	-inline void SessionSignatureResponse::clear_tosign() {
	- tosign_.ClearToEmpty();
	-}
	-inline const std::string& SessionSignatureResponse::tosign() const {
	+ inline NewPrimaryResponse* New() const final {
	+ return CreateMaybeMessage<NewPrimaryResponse>(nullptr);
	+ }
	+
	+ NewPrimaryResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<NewPrimaryResponse>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const NewPrimaryResponse& from);
	+ void MergeFrom(const NewPrimaryResponse& from);
	+ 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;
	+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
	+ int GetCachedSize() const final { return _cached_size_.Get(); }
	+
	+ private:
	+ inline void SharedCtor();
	+ inline void SharedDtor();
	+ void SetCachedSize(int size) const final;
	+ void InternalSwap(NewPrimaryResponse* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "tunnelbroker.NewPrimaryResponse";
	+ }
	+ protected:
	+ explicit NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ private:
	+ static void ArenaDtor(void* object);
	+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ public:
	+
	+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
	+ private:
	+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
	+ return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kSuccessFieldNumber = 1,
	+ };
	+ // bool success = 1;
	+ void clear_success();
	+ bool success() const;
	+ void set_success(bool value);
	+ private:
	+ bool _internal_success() const;
	+ void _internal_set_success(bool value);
	+ public:
	+
	+ // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryResponse)
	+ private:
	+ class _Internal;
	+
	+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	+ typedef void InternalArenaConstructable_;
	+ typedef void DestructorSkippable_;
	+ bool success_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_tunnelbroker_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class PongRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.PongRequest) */ {
	+ public:
	+ inline PongRequest() : PongRequest(nullptr) {}
	+ virtual ~PongRequest();
	+ explicit constexpr PongRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ PongRequest(const PongRequest& from);
	+ PongRequest(PongRequest&& from) noexcept
	+ : PongRequest() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline PongRequest& operator=(const PongRequest& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline PongRequest& operator=(PongRequest&& from) noexcept {
	+ if (GetArena() == from.GetArena()) {
	+ if (this != &from) InternalSwap(&from);
	+ } else {
	+ CopyFrom(from);
	+ }
	+ return *this;
	+ }
	+
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
	+ return GetDescriptor();
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
	+ return GetMetadataStatic().descriptor;
	+ }
	+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
	+ return GetMetadataStatic().reflection;
	+ }
	+ static const PongRequest& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const PongRequest* internal_default_instance() {
	+ return reinterpret_cast<const PongRequest*>(
	+ &_PongRequest_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 13;
	+
	+ friend void swap(PongRequest& a, PongRequest& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(PongRequest* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(PongRequest* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline PongRequest* New() const final {
	+ return CreateMaybeMessage<PongRequest>(nullptr);
	+ }
	+
	+ PongRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<PongRequest>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const PongRequest& from);
	+ void MergeFrom(const PongRequest& from);
	+ 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;
	+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
	+ int GetCachedSize() const final { return _cached_size_.Get(); }
	+
	+ private:
	+ inline void SharedCtor();
	+ inline void SharedDtor();
	+ void SetCachedSize(int size) const final;
	+ void InternalSwap(PongRequest* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "tunnelbroker.PongRequest";
	+ }
	+ protected:
	+ explicit PongRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ private:
	+ static void ArenaDtor(void* object);
	+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
	+ public:
	+
	+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
	+ private:
	+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
	+ return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kUserIdFieldNumber = 1,
	+ kDeviceTokenFieldNumber = 2,
	+ };
	+ // string userId = 1;
	+ void clear_userid();
	+ const std::string& userid() const;
	+ void set_userid(const std::string& value);
	+ void set_userid(std::string&& value);
	+ void set_userid(const char* value);
	+ void set_userid(const char* value, size_t size);
	+ std::string* mutable_userid();
	+ std::string* release_userid();
	+ void set_allocated_userid(std::string* userid);
	+ private:
	+ const std::string& _internal_userid() const;
	+ void _internal_set_userid(const std::string& value);
	+ std::string* _internal_mutable_userid();
	+ public:
	+
	+ // string deviceToken = 2;
	+ void clear_devicetoken();
	+ const std::string& devicetoken() const;
	+ void set_devicetoken(const std::string& value);
	+ void set_devicetoken(std::string&& value);
	+ void set_devicetoken(const char* value);
	+ void set_devicetoken(const char* value, size_t size);
	+ std::string* mutable_devicetoken();
	+ std::string* release_devicetoken();
	+ void set_allocated_devicetoken(std::string* devicetoken);
	+ private:
	+ const std::string& _internal_devicetoken() const;
	+ void _internal_set_devicetoken(const std::string& value);
	+ std::string* _internal_mutable_devicetoken();
	+ public:
	+
	+ // @@protoc_insertion_point(class_scope:tunnelbroker.PongRequest)
	+ private:
	+ class _Internal;
	+
	+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	+ typedef void InternalArenaConstructable_;
	+ typedef void DestructorSkippable_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicetoken_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_tunnelbroker_2eproto;
	+};
	+// ===================================================================
	+
	+
	+// ===================================================================
	+
	+#ifdef __GNUC__
	+ #pragma GCC diagnostic push
	+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
	+#endif // __GNUC__
	+// SessionSignatureRequest
	+
	+// string deviceID = 1;
	+inline void SessionSignatureRequest::clear_deviceid() {
	+ deviceid_.ClearToEmpty();
	+}
	+inline const std::string& SessionSignatureRequest::deviceid() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureRequest.deviceID)
	+ return _internal_deviceid();
	+}
	+inline void SessionSignatureRequest::set_deviceid(const std::string& value) {
	+ _internal_set_deviceid(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureRequest.deviceID)
	+}
	+inline std::string* SessionSignatureRequest::mutable_deviceid() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureRequest.deviceID)
	+ return _internal_mutable_deviceid();
	+}
	+inline const std::string& SessionSignatureRequest::_internal_deviceid() const {
	+ return deviceid_.Get();
	+}
	+inline void SessionSignatureRequest::_internal_set_deviceid(const std::string& value) {
	+
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void SessionSignatureRequest::set_deviceid(std::string&& value) {
	+
	+ deviceid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureRequest.deviceID)
	+}
	+inline void SessionSignatureRequest::set_deviceid(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureRequest.deviceID)
	+}
	+inline void SessionSignatureRequest::set_deviceid(const char* value,
	+ size_t size) {
	+
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureRequest.deviceID)
	+}
	+inline std::string* SessionSignatureRequest::_internal_mutable_deviceid() {
	+
	+ return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* SessionSignatureRequest::release_deviceid() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureRequest.deviceID)
	+ return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void SessionSignatureRequest::set_allocated_deviceid(std::string* deviceid) {
	+ if (deviceid != nullptr) {
	+
	+ } else {
	+
	+ }
	+ deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureRequest.deviceID)
	+}
	+
	+// -------------------------------------------------------------------
	+
	+// SessionSignatureResponse
	+
	+// string toSign = 1;
	+inline void SessionSignatureResponse::clear_tosign() {
	+ tosign_.ClearToEmpty();
	+}
	+inline const std::string& SessionSignatureResponse::tosign() const {
	// @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureResponse.toSign)
	return _internal_tosign();
	}
	-inline void SessionSignatureResponse::set_tosign(const std::string& value) {
	- _internal_set_tosign(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureResponse.toSign)
	+inline void SessionSignatureResponse::set_tosign(const std::string& value) {
	+ _internal_set_tosign(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureResponse.toSign)
	+}
	+inline std::string* SessionSignatureResponse::mutable_tosign() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureResponse.toSign)
	+ return _internal_mutable_tosign();
	+}
	+inline const std::string& SessionSignatureResponse::_internal_tosign() const {
	+ return tosign_.Get();
	+}
	+inline void SessionSignatureResponse::_internal_set_tosign(const std::string& value) {
	+
	+ tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void SessionSignatureResponse::set_tosign(std::string&& value) {
	+
	+ tosign_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureResponse.toSign)
	+}
	+inline void SessionSignatureResponse::set_tosign(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureResponse.toSign)
	+}
	+inline void SessionSignatureResponse::set_tosign(const char* value,
	+ size_t size) {
	+
	+ tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureResponse.toSign)
	+}
	+inline std::string* SessionSignatureResponse::_internal_mutable_tosign() {
	+
	+ return tosign_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* SessionSignatureResponse::release_tosign() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureResponse.toSign)
	+ return tosign_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void SessionSignatureResponse::set_allocated_tosign(std::string* tosign) {
	+ if (tosign != nullptr) {
	+
	+ } else {
	+
	+ }
	+ tosign_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tosign,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureResponse.toSign)
	+}
	+
	+// -------------------------------------------------------------------
	+
	+// NewSessionRequest
	+
	+// string deviceID = 1;
	+inline void NewSessionRequest::clear_deviceid() {
	+ deviceid_.ClearToEmpty();
	+}
	+inline const std::string& NewSessionRequest::deviceid() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceID)
	+ return _internal_deviceid();
	+}
	+inline void NewSessionRequest::set_deviceid(const std::string& value) {
	+ _internal_set_deviceid(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceID)
	+}
	+inline std::string* NewSessionRequest::mutable_deviceid() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceID)
	+ return _internal_mutable_deviceid();
	+}
	+inline const std::string& NewSessionRequest::_internal_deviceid() const {
	+ return deviceid_.Get();
	+}
	+inline void NewSessionRequest::_internal_set_deviceid(const std::string& value) {
	+
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void NewSessionRequest::set_deviceid(std::string&& value) {
	+
	+ deviceid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceID)
	+}
	+inline void NewSessionRequest::set_deviceid(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceID)
	+}
	+inline void NewSessionRequest::set_deviceid(const char* value,
	+ size_t size) {
	+
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceID)
	+}
	+inline std::string* NewSessionRequest::_internal_mutable_deviceid() {
	+
	+ return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* NewSessionRequest::release_deviceid() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceID)
	+ return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void NewSessionRequest::set_allocated_deviceid(std::string* deviceid) {
	+ if (deviceid != nullptr) {
	+
	+ } else {
	+
	+ }
	+ deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceID)
	+}
	+
	+// string publicKey = 2;
	+inline void NewSessionRequest::clear_publickey() {
	+ publickey_.ClearToEmpty();
	+}
	+inline const std::string& NewSessionRequest::publickey() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.publicKey)
	+ return _internal_publickey();
	+}
	+inline void NewSessionRequest::set_publickey(const std::string& value) {
	+ _internal_set_publickey(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.publicKey)
	+}
	+inline std::string* NewSessionRequest::mutable_publickey() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.publicKey)
	+ return _internal_mutable_publickey();
	+}
	+inline const std::string& NewSessionRequest::_internal_publickey() const {
	+ return publickey_.Get();
	+}
	+inline void NewSessionRequest::_internal_set_publickey(const std::string& value) {
	+
	+ publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void NewSessionRequest::set_publickey(std::string&& value) {
	+
	+ publickey_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.publicKey)
	+}
	+inline void NewSessionRequest::set_publickey(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.publicKey)
	+}
	+inline void NewSessionRequest::set_publickey(const char* value,
	+ size_t size) {
	+
	+ publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.publicKey)
	+}
	+inline std::string* NewSessionRequest::_internal_mutable_publickey() {
	+
	+ return publickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* NewSessionRequest::release_publickey() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.publicKey)
	+ return publickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void NewSessionRequest::set_allocated_publickey(std::string* publickey) {
	+ if (publickey != nullptr) {
	+
	+ } else {
	+
	+ }
	+ publickey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), publickey,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.publicKey)
	+}
	+
	+// string signature = 3;
	+inline void NewSessionRequest::clear_signature() {
	+ signature_.ClearToEmpty();
	+}
	+inline const std::string& NewSessionRequest::signature() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.signature)
	+ return _internal_signature();
	+}
	+inline void NewSessionRequest::set_signature(const std::string& value) {
	+ _internal_set_signature(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.signature)
	+}
	+inline std::string* NewSessionRequest::mutable_signature() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.signature)
	+ return _internal_mutable_signature();
	+}
	+inline const std::string& NewSessionRequest::_internal_signature() const {
	+ return signature_.Get();
	+}
	+inline void NewSessionRequest::_internal_set_signature(const std::string& value) {
	+
	+ signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void NewSessionRequest::set_signature(std::string&& value) {
	+
	+ signature_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.signature)
	+}
	+inline void NewSessionRequest::set_signature(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.signature)
	+}
	+inline void NewSessionRequest::set_signature(const char* value,
	+ size_t size) {
	+
	+ signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.signature)
	+}
	+inline std::string* NewSessionRequest::_internal_mutable_signature() {
	+
	+ return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* NewSessionRequest::release_signature() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.signature)
	+ return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void NewSessionRequest::set_allocated_signature(std::string* signature) {
	+ if (signature != nullptr) {
	+
	+ } else {
	+
	+ }
	+ signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.signature)
	+}
	+
	+// string notifyToken = 4;
	+inline bool NewSessionRequest::_internal_has_notifytoken() const {
	+ bool value = (_has_bits_[0] & 0x00000001u) != 0;
	+ return value;
	+}
	+inline bool NewSessionRequest::has_notifytoken() const {
	+ return _internal_has_notifytoken();
	+}
	+inline void NewSessionRequest::clear_notifytoken() {
	+ notifytoken_.ClearToEmpty();
	+ _has_bits_[0] &= ~0x00000001u;
	+}
	+inline const std::string& NewSessionRequest::notifytoken() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.notifyToken)
	+ return _internal_notifytoken();
	+}
	+inline void NewSessionRequest::set_notifytoken(const std::string& value) {
	+ _internal_set_notifytoken(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.notifyToken)
	+}
	+inline std::string* NewSessionRequest::mutable_notifytoken() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.notifyToken)
	+ return _internal_mutable_notifytoken();
	+}
	+inline const std::string& NewSessionRequest::_internal_notifytoken() const {
	+ return notifytoken_.Get();
	+}
	+inline void NewSessionRequest::_internal_set_notifytoken(const std::string& value) {
	+ _has_bits_[0] \|= 0x00000001u;
	+ notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void NewSessionRequest::set_notifytoken(std::string&& value) {
	+ _has_bits_[0] \|= 0x00000001u;
	+ notifytoken_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.notifyToken)
	+}
	+inline void NewSessionRequest::set_notifytoken(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ _has_bits_[0] \|= 0x00000001u;
	+ notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.notifyToken)
	+}
	+inline void NewSessionRequest::set_notifytoken(const char* value,
	+ size_t size) {
	+ _has_bits_[0] \|= 0x00000001u;
	+ notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.notifyToken)
	+}
	+inline std::string* NewSessionRequest::_internal_mutable_notifytoken() {
	+ _has_bits_[0] \|= 0x00000001u;
	+ return notifytoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* NewSessionRequest::release_notifytoken() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.notifyToken)
	+ if (!_internal_has_notifytoken()) {
	+ return nullptr;
	+ }
	+ _has_bits_[0] &= ~0x00000001u;
	+ return notifytoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void NewSessionRequest::set_allocated_notifytoken(std::string* notifytoken) {
	+ if (notifytoken != nullptr) {
	+ _has_bits_[0] \|= 0x00000001u;
	+ } else {
	+ _has_bits_[0] &= ~0x00000001u;
	+ }
	+ notifytoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), notifytoken,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.notifyToken)
	+}
	+
	+// .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5;
	+inline void NewSessionRequest::clear_devicetype() {
	+ devicetype_ = 0;
	+}
	+inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::_internal_devicetype() const {
	+ return static_cast< ::tunnelbroker::NewSessionRequest_DeviceTypes >(devicetype_);
	+}
	+inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::devicetype() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceType)
	+ return _internal_devicetype();
	+}
	+inline void NewSessionRequest::_internal_set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
	+
	+ devicetype_ = value;
	+}
	+inline void NewSessionRequest::set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
	+ _internal_set_devicetype(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceType)
	+}
	+
	+// string deviceAppVersion = 6;
	+inline void NewSessionRequest::clear_deviceappversion() {
	+ deviceappversion_.ClearToEmpty();
	+}
	+inline const std::string& NewSessionRequest::deviceappversion() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+ return _internal_deviceappversion();
	+}
	+inline void NewSessionRequest::set_deviceappversion(const std::string& value) {
	+ _internal_set_deviceappversion(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+}
	+inline std::string* NewSessionRequest::mutable_deviceappversion() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+ return _internal_mutable_deviceappversion();
	+}
	+inline const std::string& NewSessionRequest::_internal_deviceappversion() const {
	+ return deviceappversion_.Get();
	+}
	+inline void NewSessionRequest::_internal_set_deviceappversion(const std::string& value) {
	+
	+ deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void NewSessionRequest::set_deviceappversion(std::string&& value) {
	+
	+ deviceappversion_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+}
	+inline void NewSessionRequest::set_deviceappversion(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+}
	+inline void NewSessionRequest::set_deviceappversion(const char* value,
	+ size_t size) {
	+
	+ deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+}
	+inline std::string* NewSessionRequest::_internal_mutable_deviceappversion() {
	+
	+ return deviceappversion_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* NewSessionRequest::release_deviceappversion() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+ return deviceappversion_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void NewSessionRequest::set_allocated_deviceappversion(std::string* deviceappversion) {
	+ if (deviceappversion != nullptr) {
	+
	+ } else {
	+
	+ }
	+ deviceappversion_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceappversion,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceAppVersion)
	}
	-inline std::string* SessionSignatureResponse::mutable_tosign() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureResponse.toSign)
	- return _internal_mutable_tosign();
	+
	+// string deviceOS = 7;
	+inline void NewSessionRequest::clear_deviceos() {
	+ deviceos_.ClearToEmpty();
	}
	-inline const std::string& SessionSignatureResponse::_internal_tosign() const {
	- return tosign_.Get();
	+inline const std::string& NewSessionRequest::deviceos() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceOS)
	+ return _internal_deviceos();
	}
	-inline void SessionSignatureResponse::_internal_set_tosign(const std::string& value) {
	+inline void NewSessionRequest::set_deviceos(const std::string& value) {
	+ _internal_set_deviceos(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceOS)
	+}
	+inline std::string* NewSessionRequest::mutable_deviceos() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceOS)
	+ return _internal_mutable_deviceos();
	+}
	+inline const std::string& NewSessionRequest::_internal_deviceos() const {
	+ return deviceos_.Get();
	+}
	+inline void NewSessionRequest::_internal_set_deviceos(const std::string& value) {

	- tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void SessionSignatureResponse::set_tosign(std::string&& value) {
	+inline void NewSessionRequest::set_deviceos(std::string&& value) {

	- tosign_.Set(
	+ deviceos_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureResponse.toSign)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceOS)
	}
	-inline void SessionSignatureResponse::set_tosign(const char* value) {
	+inline void NewSessionRequest::set_deviceos(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	- tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureResponse.toSign)
	+ deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceOS)
	}
	-inline void SessionSignatureResponse::set_tosign(const char* value,
	+inline void NewSessionRequest::set_deviceos(const char* value,
	size_t size) {

	- tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureResponse.toSign)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceOS)
	}
	-inline std::string* SessionSignatureResponse::_internal_mutable_tosign() {
	+inline std::string* NewSessionRequest::_internal_mutable_deviceos() {

	- return tosign_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ return deviceos_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* SessionSignatureResponse::release_tosign() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureResponse.toSign)
	- return tosign_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* NewSessionRequest::release_deviceos() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceOS)
	+ return deviceos_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void SessionSignatureResponse::set_allocated_tosign(std::string* tosign) {
	- if (tosign != nullptr) {
	+inline void NewSessionRequest::set_allocated_deviceos(std::string* deviceos) {
	+ if (deviceos != nullptr) {

	} else {

	}
	- tosign_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tosign,
	+ deviceos_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceos,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureResponse.toSign)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceOS)
	}

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

	-// NewSessionRequest
	+// NewSessionResponse

	-// string deviceID = 1;
	-inline void NewSessionRequest::clear_deviceid() {
	- deviceid_.ClearToEmpty();
	+// string sessionID = 1;
	+inline void NewSessionResponse::clear_sessionid() {
	+ sessionid_.ClearToEmpty();
	}
	-inline const std::string& NewSessionRequest::deviceid() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceID)
	- return _internal_deviceid();
	+inline const std::string& NewSessionResponse::sessionid() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionResponse.sessionID)
	+ return _internal_sessionid();
	}
	-inline void NewSessionRequest::set_deviceid(const std::string& value) {
	- _internal_set_deviceid(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceID)
	+inline void NewSessionResponse::set_sessionid(const std::string& value) {
	+ _internal_set_sessionid(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionResponse.sessionID)
	}
	-inline std::string* NewSessionRequest::mutable_deviceid() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceID)
	- return _internal_mutable_deviceid();
	+inline std::string* NewSessionResponse::mutable_sessionid() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionResponse.sessionID)
	+ return _internal_mutable_sessionid();
	}
	-inline const std::string& NewSessionRequest::_internal_deviceid() const {
	- return deviceid_.Get();
	+inline const std::string& NewSessionResponse::_internal_sessionid() const {
	+ return sessionid_.Get();
	}
	-inline void NewSessionRequest::_internal_set_deviceid(const std::string& value) {
	+inline void NewSessionResponse::_internal_set_sessionid(const std::string& value) {

	- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void NewSessionRequest::set_deviceid(std::string&& value) {
	+inline void NewSessionResponse::set_sessionid(std::string&& value) {

	- deviceid_.Set(
	+ sessionid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceID)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionResponse.sessionID)
	}
	-inline void NewSessionRequest::set_deviceid(const char* value) {
	+inline void NewSessionResponse::set_sessionid(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceID)
	+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionResponse.sessionID)
	}
	-inline void NewSessionRequest::set_deviceid(const char* value,
	+inline void NewSessionResponse::set_sessionid(const char* value,
	size_t size) {

	- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceID)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionResponse.sessionID)
	}
	-inline std::string* NewSessionRequest::_internal_mutable_deviceid() {
	+inline std::string* NewSessionResponse::_internal_mutable_sessionid() {

	- return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* NewSessionRequest::release_deviceid() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceID)
	- return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* NewSessionResponse::release_sessionid() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionResponse.sessionID)
	+ return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void NewSessionRequest::set_allocated_deviceid(std::string* deviceid) {
	- if (deviceid != nullptr) {
	+inline void NewSessionResponse::set_allocated_sessionid(std::string* sessionid) {
	+ if (sessionid != nullptr) {

	} else {

	}
	- deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
	+ sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceID)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionResponse.sessionID)
	}

	-// bytes publicKey = 2;
	-inline void NewSessionRequest::clear_publickey() {
	- publickey_.ClearToEmpty();
	+// -------------------------------------------------------------------
	+
	+// SendRequest
	+
	+// string sessionID = 1;
	+inline void SendRequest::clear_sessionid() {
	+ sessionid_.ClearToEmpty();
	}
	-inline const std::string& NewSessionRequest::publickey() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.publicKey)
	- return _internal_publickey();
	+inline const std::string& SendRequest::sessionid() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.sessionID)
	+ return _internal_sessionid();
	}
	-inline void NewSessionRequest::set_publickey(const std::string& value) {
	- _internal_set_publickey(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.publicKey)
	+inline void SendRequest::set_sessionid(const std::string& value) {
	+ _internal_set_sessionid(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.sessionID)
	}
	-inline std::string* NewSessionRequest::mutable_publickey() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.publicKey)
	- return _internal_mutable_publickey();
	+inline std::string* SendRequest::mutable_sessionid() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.sessionID)
	+ return _internal_mutable_sessionid();
	}
	-inline const std::string& NewSessionRequest::_internal_publickey() const {
	- return publickey_.Get();
	+inline const std::string& SendRequest::_internal_sessionid() const {
	+ return sessionid_.Get();
	}
	-inline void NewSessionRequest::_internal_set_publickey(const std::string& value) {
	+inline void SendRequest::_internal_set_sessionid(const std::string& value) {

	- publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void NewSessionRequest::set_publickey(std::string&& value) {
	+inline void SendRequest::set_sessionid(std::string&& value) {

	- publickey_.Set(
	+ sessionid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.publicKey)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.sessionID)
	}
	-inline void NewSessionRequest::set_publickey(const char* value) {
	+inline void SendRequest::set_sessionid(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	- publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.publicKey)
	+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.sessionID)
	+}
	+inline void SendRequest::set_sessionid(const char* value,
	+ size_t size) {
	+
	+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.sessionID)
	+}
	+inline std::string* SendRequest::_internal_mutable_sessionid() {
	+
	+ return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* SendRequest::release_sessionid() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.sessionID)
	+ return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void SendRequest::set_allocated_sessionid(std::string* sessionid) {
	+ if (sessionid != nullptr) {
	+
	+ } else {
	+
	+ }
	+ sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.sessionID)
	+}
	+
	+// string toDeviceID = 2;
	+inline void SendRequest::clear_todeviceid() {
	+ todeviceid_.ClearToEmpty();
	+}
	+inline const std::string& SendRequest::todeviceid() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.toDeviceID)
	+ return _internal_todeviceid();
	+}
	+inline void SendRequest::set_todeviceid(const std::string& value) {
	+ _internal_set_todeviceid(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.toDeviceID)
	+}
	+inline std::string* SendRequest::mutable_todeviceid() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.toDeviceID)
	+ return _internal_mutable_todeviceid();
	+}
	+inline const std::string& SendRequest::_internal_todeviceid() const {
	+ return todeviceid_.Get();
	+}
	+inline void SendRequest::_internal_set_todeviceid(const std::string& value) {
	+
	+ todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void SendRequest::set_todeviceid(std::string&& value) {
	+
	+ todeviceid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.toDeviceID)
	+}
	+inline void SendRequest::set_todeviceid(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.toDeviceID)
	}
	-inline void NewSessionRequest::set_publickey(const void* value,
	+inline void SendRequest::set_todeviceid(const char* value,
	size_t size) {

	- publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.publicKey)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.toDeviceID)
	}
	-inline std::string* NewSessionRequest::_internal_mutable_publickey() {
	+inline std::string* SendRequest::_internal_mutable_todeviceid() {

	- return publickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ return todeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* NewSessionRequest::release_publickey() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.publicKey)
	- return publickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* SendRequest::release_todeviceid() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.toDeviceID)
	+ return todeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void NewSessionRequest::set_allocated_publickey(std::string* publickey) {
	- if (publickey != nullptr) {
	+inline void SendRequest::set_allocated_todeviceid(std::string* todeviceid) {
	+ if (todeviceid != nullptr) {

	} else {

	}
	- publickey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), publickey,
	+ todeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), todeviceid,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.publicKey)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.toDeviceID)
	}

	-// string signature = 3;
	-inline void NewSessionRequest::clear_signature() {
	- signature_.ClearToEmpty();
	+// bytes payload = 3;
	+inline void SendRequest::clear_payload() {
	+ payload_.ClearToEmpty();
	}
	-inline const std::string& NewSessionRequest::signature() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.signature)
	- return _internal_signature();
	+inline const std::string& SendRequest::payload() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.payload)
	+ return _internal_payload();
	}
	-inline void NewSessionRequest::set_signature(const std::string& value) {
	- _internal_set_signature(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.signature)
	+inline void SendRequest::set_payload(const std::string& value) {
	+ _internal_set_payload(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.payload)
	}
	-inline std::string* NewSessionRequest::mutable_signature() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.signature)
	- return _internal_mutable_signature();
	+inline std::string* SendRequest::mutable_payload() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.payload)
	+ return _internal_mutable_payload();
	}
	-inline const std::string& NewSessionRequest::_internal_signature() const {
	- return signature_.Get();
	+inline const std::string& SendRequest::_internal_payload() const {
	+ return payload_.Get();
	}
	-inline void NewSessionRequest::_internal_set_signature(const std::string& value) {
	+inline void SendRequest::_internal_set_payload(const std::string& value) {

	- signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void NewSessionRequest::set_signature(std::string&& value) {
	+inline void SendRequest::set_payload(std::string&& value) {

	- signature_.Set(
	+ payload_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.signature)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.payload)
	}
	-inline void NewSessionRequest::set_signature(const char* value) {
	+inline void SendRequest::set_payload(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	- signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.signature)
	+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.payload)
	}
	-inline void NewSessionRequest::set_signature(const char* value,
	+inline void SendRequest::set_payload(const void* value,
	size_t size) {

	- signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.signature)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.payload)
	}
	-inline std::string* NewSessionRequest::_internal_mutable_signature() {
	+inline std::string* SendRequest::_internal_mutable_payload() {

	- return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* NewSessionRequest::release_signature() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.signature)
	- return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* SendRequest::release_payload() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.payload)
	+ return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void NewSessionRequest::set_allocated_signature(std::string* signature) {
	- if (signature != nullptr) {
	+inline void SendRequest::set_allocated_payload(std::string* payload) {
	+ if (payload != nullptr) {

	} else {

	}
	- signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
	+ payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.signature)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.payload)
	}

	-// string notifyToken = 4;
	-inline bool NewSessionRequest::_internal_has_notifytoken() const {
	- bool value = (_has_bits_[0] & 0x00000001u) != 0;
	- return value;
	+// repeated string blobHashes = 4;
	+inline int SendRequest::_internal_blobhashes_size() const {
	+ return blobhashes_.size();
	}
	-inline bool NewSessionRequest::has_notifytoken() const {
	- return _internal_has_notifytoken();
	+inline int SendRequest::blobhashes_size() const {
	+ return _internal_blobhashes_size();
	}
	-inline void NewSessionRequest::clear_notifytoken() {
	- notifytoken_.ClearToEmpty();
	- _has_bits_[0] &= ~0x00000001u;
	+inline void SendRequest::clear_blobhashes() {
	+ blobhashes_.Clear();
	}
	-inline const std::string& NewSessionRequest::notifytoken() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.notifyToken)
	- return _internal_notifytoken();
	+inline std::string* SendRequest::add_blobhashes() {
	+ // @@protoc_insertion_point(field_add_mutable:tunnelbroker.SendRequest.blobHashes)
	+ return _internal_add_blobhashes();
	}
	-inline void NewSessionRequest::set_notifytoken(const std::string& value) {
	- _internal_set_notifytoken(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.notifyToken)
	+inline const std::string& SendRequest::_internal_blobhashes(int index) const {
	+ return blobhashes_.Get(index);
	}
	-inline std::string* NewSessionRequest::mutable_notifytoken() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.notifyToken)
	- return _internal_mutable_notifytoken();
	+inline const std::string& SendRequest::blobhashes(int index) const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.blobHashes)
	+ return _internal_blobhashes(index);
	}
	-inline const std::string& NewSessionRequest::_internal_notifytoken() const {
	- return notifytoken_.Get();
	+inline std::string* SendRequest::mutable_blobhashes(int index) {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.blobHashes)
	+ return blobhashes_.Mutable(index);
	}
	-inline void NewSessionRequest::_internal_set_notifytoken(const std::string& value) {
	- _has_bits_[0] \|= 0x00000001u;
	- notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+inline void SendRequest::set_blobhashes(int index, const std::string& value) {
	+ // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
	+ blobhashes_.Mutable(index)->assign(value);
	}
	-inline void NewSessionRequest::set_notifytoken(std::string&& value) {
	- _has_bits_[0] \|= 0x00000001u;
	- notifytoken_.Set(
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.notifyToken)
	+inline void SendRequest::set_blobhashes(int index, std::string&& value) {
	+ // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
	+ blobhashes_.Mutable(index)->assign(std::move(value));
	}
	-inline void NewSessionRequest::set_notifytoken(const char* value) {
	+inline void SendRequest::set_blobhashes(int index, const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	- _has_bits_[0] \|= 0x00000001u;
	- notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.notifyToken)
	-}
	-inline void NewSessionRequest::set_notifytoken(const char* value,
	- size_t size) {
	- _has_bits_[0] \|= 0x00000001u;
	- notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	- reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.notifyToken)
	+ blobhashes_.Mutable(index)->assign(value);
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.blobHashes)
	}
	-inline std::string* NewSessionRequest::_internal_mutable_notifytoken() {
	- _has_bits_[0] \|= 0x00000001u;
	- return notifytoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+inline void SendRequest::set_blobhashes(int index, const char* value, size_t size) {
	+ blobhashes_.Mutable(index)->assign(
	+ reinterpret_cast<const char*>(value), size);
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.blobHashes)
	}
	-inline std::string* NewSessionRequest::release_notifytoken() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.notifyToken)
	- if (!_internal_has_notifytoken()) {
	- return nullptr;
	- }
	- _has_bits_[0] &= ~0x00000001u;
	- return notifytoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* SendRequest::_internal_add_blobhashes() {
	+ return blobhashes_.Add();
	}
	-inline void NewSessionRequest::set_allocated_notifytoken(std::string* notifytoken) {
	- if (notifytoken != nullptr) {
	- _has_bits_[0] \|= 0x00000001u;
	- } else {
	- _has_bits_[0] &= ~0x00000001u;
	- }
	- notifytoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), notifytoken,
	- GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.notifyToken)
	+inline void SendRequest::add_blobhashes(const std::string& value) {
	+ blobhashes_.Add()->assign(value);
	+ // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
	}
	-
	-// .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5;
	-inline void NewSessionRequest::clear_devicetype() {
	- devicetype_ = 0;
	+inline void SendRequest::add_blobhashes(std::string&& value) {
	+ blobhashes_.Add(std::move(value));
	+ // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
	}
	-inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::_internal_devicetype() const {
	- return static_cast< ::tunnelbroker::NewSessionRequest_DeviceTypes >(devicetype_);
	+inline void SendRequest::add_blobhashes(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ blobhashes_.Add()->assign(value);
	+ // @@protoc_insertion_point(field_add_char:tunnelbroker.SendRequest.blobHashes)
	}
	-inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::devicetype() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceType)
	- return _internal_devicetype();
	+inline void SendRequest::add_blobhashes(const char* value, size_t size) {
	+ blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
	+ // @@protoc_insertion_point(field_add_pointer:tunnelbroker.SendRequest.blobHashes)
	}
	-inline void NewSessionRequest::_internal_set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
	-
	- devicetype_ = value;
	+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
	+SendRequest::blobhashes() const {
	+ // @@protoc_insertion_point(field_list:tunnelbroker.SendRequest.blobHashes)
	+ return blobhashes_;
	}
	-inline void NewSessionRequest::set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
	- _internal_set_devicetype(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceType)
	+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
	+SendRequest::mutable_blobhashes() {
	+ // @@protoc_insertion_point(field_mutable_list:tunnelbroker.SendRequest.blobHashes)
	+ return &blobhashes_;
	}

	-// string deviceAppVersion = 6;
	-inline void NewSessionRequest::clear_deviceappversion() {
	- deviceappversion_.ClearToEmpty();
	+// -------------------------------------------------------------------
	+
	+// GetRequest
	+
	+// string sessionID = 1;
	+inline void GetRequest::clear_sessionid() {
	+ sessionid_.ClearToEmpty();
	}
	-inline const std::string& NewSessionRequest::deviceappversion() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceAppVersion)
	- return _internal_deviceappversion();
	+inline const std::string& GetRequest::sessionid() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.GetRequest.sessionID)
	+ return _internal_sessionid();
	}
	-inline void NewSessionRequest::set_deviceappversion(const std::string& value) {
	- _internal_set_deviceappversion(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+inline void GetRequest::set_sessionid(const std::string& value) {
	+ _internal_set_sessionid(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.GetRequest.sessionID)
	}
	-inline std::string* NewSessionRequest::mutable_deviceappversion() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceAppVersion)
	- return _internal_mutable_deviceappversion();
	+inline std::string* GetRequest::mutable_sessionid() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.GetRequest.sessionID)
	+ return _internal_mutable_sessionid();
	}
	-inline const std::string& NewSessionRequest::_internal_deviceappversion() const {
	- return deviceappversion_.Get();
	+inline const std::string& GetRequest::_internal_sessionid() const {
	+ return sessionid_.Get();
	}
	-inline void NewSessionRequest::_internal_set_deviceappversion(const std::string& value) {
	+inline void GetRequest::_internal_set_sessionid(const std::string& value) {

	- deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void NewSessionRequest::set_deviceappversion(std::string&& value) {
	+inline void GetRequest::set_sessionid(std::string&& value) {

	- deviceappversion_.Set(
	+ sessionid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetRequest.sessionID)
	}
	-inline void NewSessionRequest::set_deviceappversion(const char* value) {
	+inline void GetRequest::set_sessionid(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	- deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.GetRequest.sessionID)
	}
	-inline void NewSessionRequest::set_deviceappversion(const char* value,
	+inline void GetRequest::set_sessionid(const char* value,
	size_t size) {

	- deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetRequest.sessionID)
	}
	-inline std::string* NewSessionRequest::_internal_mutable_deviceappversion() {
	+inline std::string* GetRequest::_internal_mutable_sessionid() {

	- return deviceappversion_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* NewSessionRequest::release_deviceappversion() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceAppVersion)
	- return deviceappversion_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* GetRequest::release_sessionid() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.GetRequest.sessionID)
	+ return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void NewSessionRequest::set_allocated_deviceappversion(std::string* deviceappversion) {
	- if (deviceappversion != nullptr) {
	+inline void GetRequest::set_allocated_sessionid(std::string* sessionid) {
	+ if (sessionid != nullptr) {

	} else {

	}
	- deviceappversion_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceappversion,
	+ sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceAppVersion)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetRequest.sessionID)
	}

	-// string deviceOS = 7;
	-inline void NewSessionRequest::clear_deviceos() {
	- deviceos_.ClearToEmpty();
	+// -------------------------------------------------------------------
	+
	+// GetResponse
	+
	+// string fromDeviceID = 1;
	+inline void GetResponse::clear_fromdeviceid() {
	+ fromdeviceid_.ClearToEmpty();
	}
	-inline const std::string& NewSessionRequest::deviceos() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceOS)
	- return _internal_deviceos();
	+inline const std::string& GetResponse::fromdeviceid() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.fromDeviceID)
	+ return _internal_fromdeviceid();
	}
	-inline void NewSessionRequest::set_deviceos(const std::string& value) {
	- _internal_set_deviceos(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceOS)
	+inline void GetResponse::set_fromdeviceid(const std::string& value) {
	+ _internal_set_fromdeviceid(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.fromDeviceID)
	}
	-inline std::string* NewSessionRequest::mutable_deviceos() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceOS)
	- return _internal_mutable_deviceos();
	+inline std::string* GetResponse::mutable_fromdeviceid() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.fromDeviceID)
	+ return _internal_mutable_fromdeviceid();
	}
	-inline const std::string& NewSessionRequest::_internal_deviceos() const {
	- return deviceos_.Get();
	+inline const std::string& GetResponse::_internal_fromdeviceid() const {
	+ return fromdeviceid_.Get();
	}
	-inline void NewSessionRequest::_internal_set_deviceos(const std::string& value) {
	+inline void GetResponse::_internal_set_fromdeviceid(const std::string& value) {

	- deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void NewSessionRequest::set_deviceos(std::string&& value) {
	+inline void GetResponse::set_fromdeviceid(std::string&& value) {

	- deviceos_.Set(
	+ fromdeviceid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceOS)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.fromDeviceID)
	}
	-inline void NewSessionRequest::set_deviceos(const char* value) {
	+inline void GetResponse::set_fromdeviceid(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	- deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceOS)
	+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.fromDeviceID)
	}
	-inline void NewSessionRequest::set_deviceos(const char* value,
	+inline void GetResponse::set_fromdeviceid(const char* value,
	size_t size) {

	- deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceOS)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.fromDeviceID)
	}
	-inline std::string* NewSessionRequest::_internal_mutable_deviceos() {
	+inline std::string* GetResponse::_internal_mutable_fromdeviceid() {

	- return deviceos_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* NewSessionRequest::release_deviceos() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceOS)
	- return deviceos_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* GetResponse::release_fromdeviceid() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.fromDeviceID)
	+ return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void NewSessionRequest::set_allocated_deviceos(std::string* deviceos) {
	- if (deviceos != nullptr) {
	+inline void GetResponse::set_allocated_fromdeviceid(std::string* fromdeviceid) {
	+ if (fromdeviceid != nullptr) {

	} else {

	}
	- deviceos_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceos,
	+ fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceOS)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.fromDeviceID)
	}

	-// -------------------------------------------------------------------
	-
	-// NewSessionResponse
	-
	-// string sessionID = 1;
	-inline void NewSessionResponse::clear_sessionid() {
	- sessionid_.ClearToEmpty();
	+// bytes payload = 2;
	+inline void GetResponse::clear_payload() {
	+ payload_.ClearToEmpty();
	}
	-inline const std::string& NewSessionResponse::sessionid() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionResponse.sessionID)
	- return _internal_sessionid();
	+inline const std::string& GetResponse::payload() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.payload)
	+ return _internal_payload();
	}
	-inline void NewSessionResponse::set_sessionid(const std::string& value) {
	- _internal_set_sessionid(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionResponse.sessionID)
	+inline void GetResponse::set_payload(const std::string& value) {
	+ _internal_set_payload(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.payload)
	}
	-inline std::string* NewSessionResponse::mutable_sessionid() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionResponse.sessionID)
	- return _internal_mutable_sessionid();
	+inline std::string* GetResponse::mutable_payload() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.payload)
	+ return _internal_mutable_payload();
	}
	-inline const std::string& NewSessionResponse::_internal_sessionid() const {
	- return sessionid_.Get();
	+inline const std::string& GetResponse::_internal_payload() const {
	+ return payload_.Get();
	}
	-inline void NewSessionResponse::_internal_set_sessionid(const std::string& value) {
	+inline void GetResponse::_internal_set_payload(const std::string& value) {

	- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void NewSessionResponse::set_sessionid(std::string&& value) {
	+inline void GetResponse::set_payload(std::string&& value) {

	- sessionid_.Set(
	+ payload_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionResponse.sessionID)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.payload)
	}
	-inline void NewSessionResponse::set_sessionid(const char* value) {
	+inline void GetResponse::set_payload(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionResponse.sessionID)
	+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.payload)
	}
	-inline void NewSessionResponse::set_sessionid(const char* value,
	+inline void GetResponse::set_payload(const void* value,
	size_t size) {

	- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionResponse.sessionID)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.payload)
	}
	-inline std::string* NewSessionResponse::_internal_mutable_sessionid() {
	+inline std::string* GetResponse::_internal_mutable_payload() {

	- return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* NewSessionResponse::release_sessionid() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionResponse.sessionID)
	- return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* GetResponse::release_payload() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.payload)
	+ return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void NewSessionResponse::set_allocated_sessionid(std::string* sessionid) {
	- if (sessionid != nullptr) {
	+inline void GetResponse::set_allocated_payload(std::string* payload) {
	+ if (payload != nullptr) {

	} else {

	}
	- sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
	+ payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionResponse.sessionID)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.payload)
	}

	-// -------------------------------------------------------------------
	-
	-// SendRequest
	-
	-// string sessionID = 1;
	-inline void SendRequest::clear_sessionid() {
	- sessionid_.ClearToEmpty();
	+// repeated string blobHashes = 3;
	+inline int GetResponse::_internal_blobhashes_size() const {
	+ return blobhashes_.size();
	}
	-inline const std::string& SendRequest::sessionid() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.sessionID)
	- return _internal_sessionid();
	+inline int GetResponse::blobhashes_size() const {
	+ return _internal_blobhashes_size();
	}
	-inline void SendRequest::set_sessionid(const std::string& value) {
	- _internal_set_sessionid(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.sessionID)
	+inline void GetResponse::clear_blobhashes() {
	+ blobhashes_.Clear();
	}
	-inline std::string* SendRequest::mutable_sessionid() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.sessionID)
	- return _internal_mutable_sessionid();
	+inline std::string* GetResponse::add_blobhashes() {
	+ // @@protoc_insertion_point(field_add_mutable:tunnelbroker.GetResponse.blobHashes)
	+ return _internal_add_blobhashes();
	}
	-inline const std::string& SendRequest::_internal_sessionid() const {
	- return sessionid_.Get();
	+inline const std::string& GetResponse::_internal_blobhashes(int index) const {
	+ return blobhashes_.Get(index);
	}
	-inline void SendRequest::_internal_set_sessionid(const std::string& value) {
	-
	- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+inline const std::string& GetResponse::blobhashes(int index) const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.blobHashes)
	+ return _internal_blobhashes(index);
	}
	-inline void SendRequest::set_sessionid(std::string&& value) {
	-
	- sessionid_.Set(
	- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.sessionID)
	+inline std::string* GetResponse::mutable_blobhashes(int index) {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.blobHashes)
	+ return blobhashes_.Mutable(index);
	}
	-inline void SendRequest::set_sessionid(const char* value) {
	+inline void GetResponse::set_blobhashes(int index, const std::string& value) {
	+ // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
	+ blobhashes_.Mutable(index)->assign(value);
	+}
	+inline void GetResponse::set_blobhashes(int index, std::string&& value) {
	+ // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
	+ blobhashes_.Mutable(index)->assign(std::move(value));
	+}
	+inline void GetResponse::set_blobhashes(int index, const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	-
	- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.sessionID)
	+ blobhashes_.Mutable(index)->assign(value);
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.blobHashes)
	}
	-inline void SendRequest::set_sessionid(const char* value,
	- size_t size) {
	-
	- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	- reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.sessionID)
	+inline void GetResponse::set_blobhashes(int index, const char* value, size_t size) {
	+ blobhashes_.Mutable(index)->assign(
	+ reinterpret_cast<const char*>(value), size);
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.blobHashes)
	+}
	+inline std::string* GetResponse::_internal_add_blobhashes() {
	+ return blobhashes_.Add();
	+}
	+inline void GetResponse::add_blobhashes(const std::string& value) {
	+ blobhashes_.Add()->assign(value);
	+ // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
	+}
	+inline void GetResponse::add_blobhashes(std::string&& value) {
	+ blobhashes_.Add(std::move(value));
	+ // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
	}
	-inline std::string* SendRequest::_internal_mutable_sessionid() {
	-
	- return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+inline void GetResponse::add_blobhashes(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ blobhashes_.Add()->assign(value);
	+ // @@protoc_insertion_point(field_add_char:tunnelbroker.GetResponse.blobHashes)
	}
	-inline std::string* SendRequest::release_sessionid() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.sessionID)
	- return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline void GetResponse::add_blobhashes(const char* value, size_t size) {
	+ blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
	+ // @@protoc_insertion_point(field_add_pointer:tunnelbroker.GetResponse.blobHashes)
	}
	-inline void SendRequest::set_allocated_sessionid(std::string* sessionid) {
	- if (sessionid != nullptr) {
	-
	- } else {
	-
	- }
	- sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
	- GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.sessionID)
	+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
	+GetResponse::blobhashes() const {
	+ // @@protoc_insertion_point(field_list:tunnelbroker.GetResponse.blobHashes)
	+ return blobhashes_;
	+}
	+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
	+GetResponse::mutable_blobhashes() {
	+ // @@protoc_insertion_point(field_mutable_list:tunnelbroker.GetResponse.blobHashes)
	+ return &blobhashes_;
	}

	-// string toDeviceID = 2;
	-inline void SendRequest::clear_todeviceid() {
	+// -------------------------------------------------------------------
	+
	+// OutboundMessage
	+
	+// string toDeviceID = 1;
	+inline void OutboundMessage::clear_todeviceid() {
	todeviceid_.ClearToEmpty();
	}
	-inline const std::string& SendRequest::todeviceid() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.toDeviceID)
	+inline const std::string& OutboundMessage::todeviceid() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.toDeviceID)
	return _internal_todeviceid();
	}
	-inline void SendRequest::set_todeviceid(const std::string& value) {
	+inline void OutboundMessage::set_todeviceid(const std::string& value) {
	_internal_set_todeviceid(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.toDeviceID)
	+ // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.toDeviceID)
	}
	-inline std::string* SendRequest::mutable_todeviceid() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.toDeviceID)
	+inline std::string* OutboundMessage::mutable_todeviceid() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.toDeviceID)
	return _internal_mutable_todeviceid();
	}
	-inline const std::string& SendRequest::_internal_todeviceid() const {
	+inline const std::string& OutboundMessage::_internal_todeviceid() const {
	return todeviceid_.Get();
	}
	-inline void SendRequest::_internal_set_todeviceid(const std::string& value) {
	+inline void OutboundMessage::_internal_set_todeviceid(const std::string& value) {

	todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void SendRequest::set_todeviceid(std::string&& value) {
	+inline void OutboundMessage::set_todeviceid(std::string&& value) {

	todeviceid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.toDeviceID)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.OutboundMessage.toDeviceID)
	}
	-inline void SendRequest::set_todeviceid(const char* value) {
	+inline void OutboundMessage::set_todeviceid(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.toDeviceID)
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.toDeviceID)
	}
	-inline void SendRequest::set_todeviceid(const char* value,
	+inline void OutboundMessage::set_todeviceid(const char* value,
	size_t size) {

	todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.toDeviceID)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.toDeviceID)
	}
	-inline std::string* SendRequest::_internal_mutable_todeviceid() {
	+inline std::string* OutboundMessage::_internal_mutable_todeviceid() {

	return todeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* SendRequest::release_todeviceid() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.toDeviceID)
	+inline std::string* OutboundMessage::release_todeviceid() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.OutboundMessage.toDeviceID)
	return todeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void SendRequest::set_allocated_todeviceid(std::string* todeviceid) {
	+inline void OutboundMessage::set_allocated_todeviceid(std::string* todeviceid) {
	if (todeviceid != nullptr) {

	} else {
	@@ -2902,60 +3769,60 @@
	}
	todeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), todeviceid,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.toDeviceID)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.OutboundMessage.toDeviceID)
	}

	-// bytes payload = 3;
	-inline void SendRequest::clear_payload() {
	+// string payload = 2;
	+inline void OutboundMessage::clear_payload() {
	payload_.ClearToEmpty();
	}
	-inline const std::string& SendRequest::payload() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.payload)
	+inline const std::string& OutboundMessage::payload() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.payload)
	return _internal_payload();
	}
	-inline void SendRequest::set_payload(const std::string& value) {
	+inline void OutboundMessage::set_payload(const std::string& value) {
	_internal_set_payload(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.payload)
	+ // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.payload)
	}
	-inline std::string* SendRequest::mutable_payload() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.payload)
	+inline std::string* OutboundMessage::mutable_payload() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.payload)
	return _internal_mutable_payload();
	}
	-inline const std::string& SendRequest::_internal_payload() const {
	+inline const std::string& OutboundMessage::_internal_payload() const {
	return payload_.Get();
	}
	-inline void SendRequest::_internal_set_payload(const std::string& value) {
	+inline void OutboundMessage::_internal_set_payload(const std::string& value) {

	payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void SendRequest::set_payload(std::string&& value) {
	+inline void OutboundMessage::set_payload(std::string&& value) {

	payload_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.payload)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.OutboundMessage.payload)
	}
	-inline void SendRequest::set_payload(const char* value) {
	+inline void OutboundMessage::set_payload(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.payload)
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.payload)
	}
	-inline void SendRequest::set_payload(const void* value,
	+inline void OutboundMessage::set_payload(const char* value,
	size_t size) {

	payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.payload)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.payload)
	}
	-inline std::string* SendRequest::_internal_mutable_payload() {
	+inline std::string* OutboundMessage::_internal_mutable_payload() {

	return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* SendRequest::release_payload() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.payload)
	+inline std::string* OutboundMessage::release_payload() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.OutboundMessage.payload)
	return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void SendRequest::set_allocated_payload(std::string* payload) {
	+inline void OutboundMessage::set_allocated_payload(std::string* payload) {
	if (payload != nullptr) {

	} else {
	@@ -2963,264 +3830,260 @@
	}
	payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.payload)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.OutboundMessage.payload)
	}

	-// repeated string blobHashes = 4;
	-inline int SendRequest::_internal_blobhashes_size() const {
	+// repeated string blobHashes = 3;
	+inline int OutboundMessage::_internal_blobhashes_size() const {
	return blobhashes_.size();
	}
	-inline int SendRequest::blobhashes_size() const {
	+inline int OutboundMessage::blobhashes_size() const {
	return _internal_blobhashes_size();
	}
	-inline void SendRequest::clear_blobhashes() {
	+inline void OutboundMessage::clear_blobhashes() {
	blobhashes_.Clear();
	}
	-inline std::string* SendRequest::add_blobhashes() {
	- // @@protoc_insertion_point(field_add_mutable:tunnelbroker.SendRequest.blobHashes)
	+inline std::string* OutboundMessage::add_blobhashes() {
	+ // @@protoc_insertion_point(field_add_mutable:tunnelbroker.OutboundMessage.blobHashes)
	return _internal_add_blobhashes();
	}
	-inline const std::string& SendRequest::_internal_blobhashes(int index) const {
	+inline const std::string& OutboundMessage::_internal_blobhashes(int index) const {
	return blobhashes_.Get(index);
	}
	-inline const std::string& SendRequest::blobhashes(int index) const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.blobHashes)
	+inline const std::string& OutboundMessage::blobhashes(int index) const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.blobHashes)
	return _internal_blobhashes(index);
	}
	-inline std::string* SendRequest::mutable_blobhashes(int index) {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.blobHashes)
	+inline std::string* OutboundMessage::mutable_blobhashes(int index) {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.blobHashes)
	return blobhashes_.Mutable(index);
	}
	-inline void SendRequest::set_blobhashes(int index, const std::string& value) {
	- // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
	+inline void OutboundMessage::set_blobhashes(int index, const std::string& value) {
	+ // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.blobHashes)
	blobhashes_.Mutable(index)->assign(value);
	}
	-inline void SendRequest::set_blobhashes(int index, std::string&& value) {
	- // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
	+inline void OutboundMessage::set_blobhashes(int index, std::string&& value) {
	+ // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.blobHashes)
	blobhashes_.Mutable(index)->assign(std::move(value));
	}
	-inline void SendRequest::set_blobhashes(int index, const char* value) {
	+inline void OutboundMessage::set_blobhashes(int index, const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	blobhashes_.Mutable(index)->assign(value);
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.blobHashes)
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.blobHashes)
	}
	-inline void SendRequest::set_blobhashes(int index, const char* value, size_t size) {
	+inline void OutboundMessage::set_blobhashes(int index, const char* value, size_t size) {
	blobhashes_.Mutable(index)->assign(
	reinterpret_cast<const char*>(value), size);
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.blobHashes)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.blobHashes)
	}
	-inline std::string* SendRequest::_internal_add_blobhashes() {
	+inline std::string* OutboundMessage::_internal_add_blobhashes() {
	return blobhashes_.Add();
	}
	-inline void SendRequest::add_blobhashes(const std::string& value) {
	+inline void OutboundMessage::add_blobhashes(const std::string& value) {
	blobhashes_.Add()->assign(value);
	- // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
	+ // @@protoc_insertion_point(field_add:tunnelbroker.OutboundMessage.blobHashes)
	}
	-inline void SendRequest::add_blobhashes(std::string&& value) {
	+inline void OutboundMessage::add_blobhashes(std::string&& value) {
	blobhashes_.Add(std::move(value));
	- // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
	+ // @@protoc_insertion_point(field_add:tunnelbroker.OutboundMessage.blobHashes)
	}
	-inline void SendRequest::add_blobhashes(const char* value) {
	+inline void OutboundMessage::add_blobhashes(const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	blobhashes_.Add()->assign(value);
	- // @@protoc_insertion_point(field_add_char:tunnelbroker.SendRequest.blobHashes)
	+ // @@protoc_insertion_point(field_add_char:tunnelbroker.OutboundMessage.blobHashes)
	}
	-inline void SendRequest::add_blobhashes(const char* value, size_t size) {
	+inline void OutboundMessage::add_blobhashes(const char* value, size_t size) {
	blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
	- // @@protoc_insertion_point(field_add_pointer:tunnelbroker.SendRequest.blobHashes)
	+ // @@protoc_insertion_point(field_add_pointer:tunnelbroker.OutboundMessage.blobHashes)
	}
	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
	-SendRequest::blobhashes() const {
	- // @@protoc_insertion_point(field_list:tunnelbroker.SendRequest.blobHashes)
	+OutboundMessage::blobhashes() const {
	+ // @@protoc_insertion_point(field_list:tunnelbroker.OutboundMessage.blobHashes)
	return blobhashes_;
	}
	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
	-SendRequest::mutable_blobhashes() {
	- // @@protoc_insertion_point(field_mutable_list:tunnelbroker.SendRequest.blobHashes)
	+OutboundMessage::mutable_blobhashes() {
	+ // @@protoc_insertion_point(field_mutable_list:tunnelbroker.OutboundMessage.blobHashes)
	return &blobhashes_;
	}

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

	-// GetRequest
	+// InboundMessage

	-// string sessionID = 1;
	-inline void GetRequest::clear_sessionid() {
	- sessionid_.ClearToEmpty();
	+// string fromDeviceID = 1;
	+inline void InboundMessage::clear_fromdeviceid() {
	+ fromdeviceid_.ClearToEmpty();
	}
	-inline const std::string& GetRequest::sessionid() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.GetRequest.sessionID)
	- return _internal_sessionid();
	+inline const std::string& InboundMessage::fromdeviceid() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.fromDeviceID)
	+ return _internal_fromdeviceid();
	}
	-inline void GetRequest::set_sessionid(const std::string& value) {
	- _internal_set_sessionid(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.GetRequest.sessionID)
	+inline void InboundMessage::set_fromdeviceid(const std::string& value) {
	+ _internal_set_fromdeviceid(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.fromDeviceID)
	}
	-inline std::string* GetRequest::mutable_sessionid() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.GetRequest.sessionID)
	- return _internal_mutable_sessionid();
	+inline std::string* InboundMessage::mutable_fromdeviceid() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.fromDeviceID)
	+ return _internal_mutable_fromdeviceid();
	}
	-inline const std::string& GetRequest::_internal_sessionid() const {
	- return sessionid_.Get();
	+inline const std::string& InboundMessage::_internal_fromdeviceid() const {
	+ return fromdeviceid_.Get();
	}
	-inline void GetRequest::_internal_set_sessionid(const std::string& value) {
	+inline void InboundMessage::_internal_set_fromdeviceid(const std::string& value) {

	- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void GetRequest::set_sessionid(std::string&& value) {
	+inline void InboundMessage::set_fromdeviceid(std::string&& value) {

	- sessionid_.Set(
	+ fromdeviceid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetRequest.sessionID)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.fromDeviceID)
	}
	-inline void GetRequest::set_sessionid(const char* value) {
	+inline void InboundMessage::set_fromdeviceid(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.GetRequest.sessionID)
	+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.fromDeviceID)
	}
	-inline void GetRequest::set_sessionid(const char* value,
	+inline void InboundMessage::set_fromdeviceid(const char* value,
	size_t size) {

	- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetRequest.sessionID)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.fromDeviceID)
	}
	-inline std::string* GetRequest::_internal_mutable_sessionid() {
	+inline std::string* InboundMessage::_internal_mutable_fromdeviceid() {

	- return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* GetRequest::release_sessionid() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.GetRequest.sessionID)
	- return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* InboundMessage::release_fromdeviceid() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.fromDeviceID)
	+ return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void GetRequest::set_allocated_sessionid(std::string* sessionid) {
	- if (sessionid != nullptr) {
	+inline void InboundMessage::set_allocated_fromdeviceid(std::string* fromdeviceid) {
	+ if (fromdeviceid != nullptr) {

	} else {

	}
	- sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
	+ fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetRequest.sessionID)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.fromDeviceID)
	}

	-// -------------------------------------------------------------------
	-
	-// GetResponse
	-
	-// string fromDeviceID = 1;
	-inline void GetResponse::clear_fromdeviceid() {
	- fromdeviceid_.ClearToEmpty();
	+// string fromConnectionID = 2;
	+inline void InboundMessage::clear_fromconnectionid() {
	+ fromconnectionid_.ClearToEmpty();
	}
	-inline const std::string& GetResponse::fromdeviceid() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.fromDeviceID)
	- return _internal_fromdeviceid();
	+inline const std::string& InboundMessage::fromconnectionid() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.fromConnectionID)
	+ return _internal_fromconnectionid();
	}
	-inline void GetResponse::set_fromdeviceid(const std::string& value) {
	- _internal_set_fromdeviceid(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.fromDeviceID)
	+inline void InboundMessage::set_fromconnectionid(const std::string& value) {
	+ _internal_set_fromconnectionid(value);
	+ // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.fromConnectionID)
	}
	-inline std::string* GetResponse::mutable_fromdeviceid() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.fromDeviceID)
	- return _internal_mutable_fromdeviceid();
	+inline std::string* InboundMessage::mutable_fromconnectionid() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.fromConnectionID)
	+ return _internal_mutable_fromconnectionid();
	}
	-inline const std::string& GetResponse::_internal_fromdeviceid() const {
	- return fromdeviceid_.Get();
	+inline const std::string& InboundMessage::_internal_fromconnectionid() const {
	+ return fromconnectionid_.Get();
	}
	-inline void GetResponse::_internal_set_fromdeviceid(const std::string& value) {
	+inline void InboundMessage::_internal_set_fromconnectionid(const std::string& value) {

	- fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+ fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void GetResponse::set_fromdeviceid(std::string&& value) {
	+inline void InboundMessage::set_fromconnectionid(std::string&& value) {

	- fromdeviceid_.Set(
	+ fromconnectionid_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.fromDeviceID)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.fromConnectionID)
	}
	-inline void GetResponse::set_fromdeviceid(const char* value) {
	+inline void InboundMessage::set_fromconnectionid(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	- fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.fromDeviceID)
	+ fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.fromConnectionID)
	}
	-inline void GetResponse::set_fromdeviceid(const char* value,
	+inline void InboundMessage::set_fromconnectionid(const char* value,
	size_t size) {

	- fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.fromDeviceID)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.fromConnectionID)
	}
	-inline std::string* GetResponse::_internal_mutable_fromdeviceid() {
	+inline std::string* InboundMessage::_internal_mutable_fromconnectionid() {

	- return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ return fromconnectionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* GetResponse::release_fromdeviceid() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.fromDeviceID)
	- return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+inline std::string* InboundMessage::release_fromconnectionid() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.fromConnectionID)
	+ return fromconnectionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void GetResponse::set_allocated_fromdeviceid(std::string* fromdeviceid) {
	- if (fromdeviceid != nullptr) {
	+inline void InboundMessage::set_allocated_fromconnectionid(std::string* fromconnectionid) {
	+ if (fromconnectionid != nullptr) {

	} else {

	}
	- fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid,
	+ fromconnectionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromconnectionid,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.fromDeviceID)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.fromConnectionID)
	}

	-// bytes payload = 2;
	-inline void GetResponse::clear_payload() {
	+// string payload = 3;
	+inline void InboundMessage::clear_payload() {
	payload_.ClearToEmpty();
	}
	-inline const std::string& GetResponse::payload() const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.payload)
	+inline const std::string& InboundMessage::payload() const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.payload)
	return _internal_payload();
	}
	-inline void GetResponse::set_payload(const std::string& value) {
	+inline void InboundMessage::set_payload(const std::string& value) {
	_internal_set_payload(value);
	- // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.payload)
	+ // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.payload)
	}
	-inline std::string* GetResponse::mutable_payload() {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.payload)
	+inline std::string* InboundMessage::mutable_payload() {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.payload)
	return _internal_mutable_payload();
	}
	-inline const std::string& GetResponse::_internal_payload() const {
	+inline const std::string& InboundMessage::_internal_payload() const {
	return payload_.Get();
	}
	-inline void GetResponse::_internal_set_payload(const std::string& value) {
	+inline void InboundMessage::_internal_set_payload(const std::string& value) {

	payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	}
	-inline void GetResponse::set_payload(std::string&& value) {
	+inline void InboundMessage::set_payload(std::string&& value) {

	payload_.Set(
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.payload)
	+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.payload)
	}
	-inline void GetResponse::set_payload(const char* value) {
	+inline void InboundMessage::set_payload(const char* value) {
	GOOGLE_DCHECK(value != nullptr);

	payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.payload)
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.payload)
	}
	-inline void GetResponse::set_payload(const void* value,
	+inline void InboundMessage::set_payload(const char* value,
	size_t size) {

	payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	reinterpret_cast<const char*>(value), size), GetArena());
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.payload)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.payload)
	}
	-inline std::string* GetResponse::_internal_mutable_payload() {
	+inline std::string* InboundMessage::_internal_mutable_payload() {

	return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	}
	-inline std::string* GetResponse::release_payload() {
	- // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.payload)
	+inline std::string* InboundMessage::release_payload() {
	+ // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.payload)
	return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	}
	-inline void GetResponse::set_allocated_payload(std::string* payload) {
	+inline void InboundMessage::set_allocated_payload(std::string* payload) {
	if (payload != nullptr) {

	} else {
	@@ -3228,80 +4091,80 @@
	}
	payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
	GetArena());
	- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.payload)
	+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.payload)
	}

	-// repeated string blobHashes = 3;
	-inline int GetResponse::_internal_blobhashes_size() const {
	+// repeated string blobHashes = 4;
	+inline int InboundMessage::_internal_blobhashes_size() const {
	return blobhashes_.size();
	}
	-inline int GetResponse::blobhashes_size() const {
	+inline int InboundMessage::blobhashes_size() const {
	return _internal_blobhashes_size();
	}
	-inline void GetResponse::clear_blobhashes() {
	+inline void InboundMessage::clear_blobhashes() {
	blobhashes_.Clear();
	}
	-inline std::string* GetResponse::add_blobhashes() {
	- // @@protoc_insertion_point(field_add_mutable:tunnelbroker.GetResponse.blobHashes)
	+inline std::string* InboundMessage::add_blobhashes() {
	+ // @@protoc_insertion_point(field_add_mutable:tunnelbroker.InboundMessage.blobHashes)
	return _internal_add_blobhashes();
	}
	-inline const std::string& GetResponse::_internal_blobhashes(int index) const {
	+inline const std::string& InboundMessage::_internal_blobhashes(int index) const {
	return blobhashes_.Get(index);
	}
	-inline const std::string& GetResponse::blobhashes(int index) const {
	- // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.blobHashes)
	+inline const std::string& InboundMessage::blobhashes(int index) const {
	+ // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.blobHashes)
	return _internal_blobhashes(index);
	}
	-inline std::string* GetResponse::mutable_blobhashes(int index) {
	- // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.blobHashes)
	+inline std::string* InboundMessage::mutable_blobhashes(int index) {
	+ // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.blobHashes)
	return blobhashes_.Mutable(index);
	}
	-inline void GetResponse::set_blobhashes(int index, const std::string& value) {
	- // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
	+inline void InboundMessage::set_blobhashes(int index, const std::string& value) {
	+ // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.blobHashes)
	blobhashes_.Mutable(index)->assign(value);
	}
	-inline void GetResponse::set_blobhashes(int index, std::string&& value) {
	- // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
	+inline void InboundMessage::set_blobhashes(int index, std::string&& value) {
	+ // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.blobHashes)
	blobhashes_.Mutable(index)->assign(std::move(value));
	}
	-inline void GetResponse::set_blobhashes(int index, const char* value) {
	+inline void InboundMessage::set_blobhashes(int index, const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	blobhashes_.Mutable(index)->assign(value);
	- // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.blobHashes)
	+ // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.blobHashes)
	}
	-inline void GetResponse::set_blobhashes(int index, const char* value, size_t size) {
	+inline void InboundMessage::set_blobhashes(int index, const char* value, size_t size) {
	blobhashes_.Mutable(index)->assign(
	reinterpret_cast<const char*>(value), size);
	- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.blobHashes)
	+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.blobHashes)
	}
	-inline std::string* GetResponse::_internal_add_blobhashes() {
	+inline std::string* InboundMessage::_internal_add_blobhashes() {
	return blobhashes_.Add();
	}
	-inline void GetResponse::add_blobhashes(const std::string& value) {
	+inline void InboundMessage::add_blobhashes(const std::string& value) {
	blobhashes_.Add()->assign(value);
	- // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
	+ // @@protoc_insertion_point(field_add:tunnelbroker.InboundMessage.blobHashes)
	}
	-inline void GetResponse::add_blobhashes(std::string&& value) {
	+inline void InboundMessage::add_blobhashes(std::string&& value) {
	blobhashes_.Add(std::move(value));
	- // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
	+ // @@protoc_insertion_point(field_add:tunnelbroker.InboundMessage.blobHashes)
	}
	-inline void GetResponse::add_blobhashes(const char* value) {
	+inline void InboundMessage::add_blobhashes(const char* value) {
	GOOGLE_DCHECK(value != nullptr);
	blobhashes_.Add()->assign(value);
	- // @@protoc_insertion_point(field_add_char:tunnelbroker.GetResponse.blobHashes)
	+ // @@protoc_insertion_point(field_add_char:tunnelbroker.InboundMessage.blobHashes)
	}
	-inline void GetResponse::add_blobhashes(const char* value, size_t size) {
	+inline void InboundMessage::add_blobhashes(const char* value, size_t size) {
	blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
	- // @@protoc_insertion_point(field_add_pointer:tunnelbroker.GetResponse.blobHashes)
	+ // @@protoc_insertion_point(field_add_pointer:tunnelbroker.InboundMessage.blobHashes)
	}
	inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
	-GetResponse::blobhashes() const {
	- // @@protoc_insertion_point(field_list:tunnelbroker.GetResponse.blobHashes)
	+InboundMessage::blobhashes() const {
	+ // @@protoc_insertion_point(field_list:tunnelbroker.InboundMessage.blobHashes)
	return blobhashes_;
	}
	inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
	-GetResponse::mutable_blobhashes() {
	- // @@protoc_insertion_point(field_mutable_list:tunnelbroker.GetResponse.blobHashes)
	+InboundMessage::mutable_blobhashes() {
	+ // @@protoc_insertion_point(field_mutable_list:tunnelbroker.InboundMessage.blobHashes)
	return &blobhashes_;
	}

	@@ -3756,6 +4619,10 @@

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

	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+

	// @@protoc_insertion_point(namespace_scope)

	diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc
	--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc
	+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc
	@@ -113,6 +113,35 @@
	};
	};
	PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetResponseDefaultTypeInternal _GetResponse_default_instance_;
	+constexpr OutboundMessage::OutboundMessage(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : blobhashes_()
	+ , todeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	+struct OutboundMessageDefaultTypeInternal {
	+ constexpr OutboundMessageDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~OutboundMessageDefaultTypeInternal() {}
	+ union {
	+ OutboundMessage _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OutboundMessageDefaultTypeInternal _OutboundMessage_default_instance_;
	+constexpr InboundMessage::InboundMessage(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : blobhashes_()
	+ , fromdeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , fromconnectionid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	+struct InboundMessageDefaultTypeInternal {
	+ constexpr InboundMessageDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~InboundMessageDefaultTypeInternal() {}
	+ union {
	+ InboundMessage _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InboundMessageDefaultTypeInternal _InboundMessage_default_instance_;
	constexpr CheckRequest::CheckRequest(
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	: userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	@@ -178,7 +207,7 @@
	};
	PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PongRequestDefaultTypeInternal _PongRequest_default_instance_;
	} // namespace tunnelbroker
	-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_tunnelbroker_2eproto[12];
	+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_tunnelbroker_2eproto[14];
	static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_tunnelbroker_2eproto[2];
	static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_tunnelbroker_2eproto = nullptr;

	@@ -244,6 +273,23 @@
	PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponse, payload_),
	PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponse, blobhashes_),
	~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ ~0u, // no _oneof_case_
	+ ~0u, // no _weak_field_map_
	+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, todeviceid_),
	+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, payload_),
	+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, blobhashes_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ ~0u, // no _oneof_case_
	+ ~0u, // no _weak_field_map_
	+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, fromdeviceid_),
	+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, fromconnectionid_),
	+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, payload_),
	+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, blobhashes_),
	+ ~0u, // no _has_bits_
	PROTOBUF_FIELD_OFFSET(::tunnelbroker::CheckRequest, _internal_metadata_),
	~0u, // no _extensions_
	~0u, // no _oneof_case_
	@@ -285,11 +331,13 @@
	{ 37, -1, sizeof(::tunnelbroker::SendRequest)},
	{ 46, -1, sizeof(::tunnelbroker::GetRequest)},
	{ 52, -1, sizeof(::tunnelbroker::GetResponse)},
	- { 60, -1, sizeof(::tunnelbroker::CheckRequest)},
	- { 67, -1, sizeof(::tunnelbroker::CheckResponse)},
	- { 73, -1, sizeof(::tunnelbroker::NewPrimaryRequest)},
	- { 80, -1, sizeof(::tunnelbroker::NewPrimaryResponse)},
	- { 86, -1, sizeof(::tunnelbroker::PongRequest)},
	+ { 60, -1, sizeof(::tunnelbroker::OutboundMessage)},
	+ { 68, -1, sizeof(::tunnelbroker::InboundMessage)},
	+ { 77, -1, sizeof(::tunnelbroker::CheckRequest)},
	+ { 84, -1, sizeof(::tunnelbroker::CheckResponse)},
	+ { 90, -1, sizeof(::tunnelbroker::NewPrimaryRequest)},
	+ { 97, -1, sizeof(::tunnelbroker::NewPrimaryResponse)},
	+ { 103, -1, sizeof(::tunnelbroker::PongRequest)},
	};

	static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
	@@ -300,6 +348,8 @@
	reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_SendRequest_default_instance_),
	reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_GetRequest_default_instance_),
	reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_GetResponse_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_OutboundMessage_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_InboundMessage_default_instance_),
	reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_CheckRequest_default_instance_),
	reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_CheckResponse_default_instance_),
	reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_NewPrimaryRequest_default_instance_),
	@@ -313,7 +363,7 @@
	"ureRequest\022\020\n\010deviceID\030\001 \001(\t\"*\n\030SessionS"
	"ignatureResponse\022\016\n\006toSign\030\001 \001(\t\"\225\002\n\021New"
	"SessionRequest\022\020\n\010deviceID\030\001 \001(\t\022\021\n\tpubl"
	- "icKey\030\002 \001(\014\022\021\n\tsignature\030\003 \001(\t\022\030\n\013notify"
	+ "icKey\030\002 \001(\t\022\021\n\tsignature\030\003 \001(\t\022\030\n\013notify"
	"Token\030\004 \001(\tH\000\210\001\001\022\?\n\ndeviceType\030\005 \001(\0162+.t"
	"unnelbroker.NewSessionRequest.DeviceType"
	"s\022\030\n\020deviceAppVersion\030\006 \001(\t\022\020\n\010deviceOS\030"
	@@ -324,40 +374,46 @@
	"D\030\002 \001(\t\022\017\n\007payload\030\003 \001(\014\022\022\n\nblobHashes\030\004"
	" \003(\t\"\037\n\nGetRequest\022\021\n\tsessionID\030\001 \001(\t\"H\n"
	"\013GetResponse\022\024\n\014fromDeviceID\030\001 \001(\t\022\017\n\007pa"
	- "yload\030\002 \001(\014\022\022\n\nblobHashes\030\003 \003(\t\"3\n\014Check"
	- "Request\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceToken\030\002"
	- " \001(\t\"K\n\rCheckResponse\022:\n\021checkResponseTy"
	- "pe\030\001 \001(\0162\037.tunnelbroker.CheckResponseTyp"
	- "e\"8\n\021NewPrimaryRequest\022\016\n\006userId\030\001 \001(\t\022\023"
	- "\n\013deviceToken\030\002 \001(\t\"%\n\022NewPrimaryRespons"
	- "e\022\017\n\007success\030\001 \001(\010\"2\n\013PongRequest\022\016\n\006use"
	- "rId\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t*n\n\021CheckR"
	- "esponseType\022\030\n\024PRIMARY_DOESNT_EXIST\020\000\022\022\n"
	- "\016PRIMARY_ONLINE\020\001\022\023\n\017PRIMARY_OFFLINE\020\002\022\026"
	- "\n\022CURRENT_IS_PRIMARY\020\0032\303\004\n\023TunnelbrokerS"
	- "ervice\022W\n\032CheckIfPrimaryDeviceOnline\022\032.t"
	- "unnelbroker.CheckRequest\032\033.tunnelbroker."
	- "CheckResponse\"\000\022]\n\026BecomeNewPrimaryDevic"
	- "e\022\037.tunnelbroker.NewPrimaryRequest\032 .tun"
	- "nelbroker.NewPrimaryResponse\"\000\022\?\n\010SendPo"
	- "ng\022\031.tunnelbroker.PongRequest\032\026.google.p"
	- "rotobuf.Empty\"\000\022c\n\020SessionSignature\022%.tu"
	- "nnelbroker.SessionSignatureRequest\032&.tun"
	- "nelbroker.SessionSignatureResponse\"\000\022Q\n\n"
	- "NewSession\022\037.tunnelbroker.NewSessionRequ"
	- "est\032 .tunnelbroker.NewSessionResponse\"\000\022"
	- ";\n\004Send\022\031.tunnelbroker.SendRequest\032\026.goo"
	- "gle.protobuf.Empty\"\000\022>\n\003Get\022\030.tunnelbrok"
	- "er.GetRequest\032\031.tunnelbroker.GetResponse"
	- "\"\0000\001b\006proto3"
	+ "yload\030\002 \001(\014\022\022\n\nblobHashes\030\003 \003(\t\"J\n\017Outbo"
	+ "undMessage\022\022\n\ntoDeviceID\030\001 \001(\t\022\017\n\007payloa"
	+ "d\030\002 \001(\t\022\022\n\nblobHashes\030\003 \003(\t\"e\n\016InboundMe"
	+ "ssage\022\024\n\014fromDeviceID\030\001 \001(\t\022\030\n\020fromConne"
	+ "ctionID\030\002 \001(\t\022\017\n\007payload\030\003 \001(\t\022\022\n\nblobHa"
	+ "shes\030\004 \003(\t\"3\n\014CheckRequest\022\016\n\006userId\030\001 \001"
	+ "(\t\022\023\n\013deviceToken\030\002 \001(\t\"K\n\rCheckResponse"
	+ "\022:\n\021checkResponseType\030\001 \001(\0162\037.tunnelbrok"
	+ "er.CheckResponseType\"8\n\021NewPrimaryReques"
	+ "t\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t\"%"
	+ "\n\022NewPrimaryResponse\022\017\n\007success\030\001 \001(\010\"2\n"
	+ "\013PongRequest\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceTo"
	+ "ken\030\002 \001(\t*n\n\021CheckResponseType\022\030\n\024PRIMAR"
	+ "Y_DOESNT_EXIST\020\000\022\022\n\016PRIMARY_ONLINE\020\001\022\023\n\017"
	+ "PRIMARY_OFFLINE\020\002\022\026\n\022CURRENT_IS_PRIMARY\020"
	+ "\0032\224\005\n\023TunnelbrokerService\022W\n\032CheckIfPrim"
	+ "aryDeviceOnline\022\032.tunnelbroker.CheckRequ"
	+ "est\032\033.tunnelbroker.CheckResponse\"\000\022]\n\026Be"
	+ "comeNewPrimaryDevice\022\037.tunnelbroker.NewP"
	+ "rimaryRequest\032 .tunnelbroker.NewPrimaryR"
	+ "esponse\"\000\022\?\n\010SendPong\022\031.tunnelbroker.Pon"
	+ "gRequest\032\026.google.protobuf.Empty\"\000\022c\n\020Se"
	+ "ssionSignature\022%.tunnelbroker.SessionSig"
	+ "natureRequest\032&.tunnelbroker.SessionSign"
	+ "atureResponse\"\000\022Q\n\nNewSession\022\037.tunnelbr"
	+ "oker.NewSessionRequest\032 .tunnelbroker.Ne"
	+ "wSessionResponse\"\000\022;\n\004Send\022\031.tunnelbroke"
	+ "r.SendRequest\032\026.google.protobuf.Empty\"\000\022"
	+ ">\n\003Get\022\030.tunnelbroker.GetRequest\032\031.tunne"
	+ "lbroker.GetResponse\"\0000\001\022O\n\nOpenStream\022\035."
	+ "tunnelbroker.OutboundMessage\032\034.tunnelbro"
	+ "ker.InboundMessage\"\000(\0010\001b\006proto3"
	;
	static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_tunnelbroker_2eproto_deps[1] = {
	&::descriptor_table_google_2fprotobuf_2fempty_2eproto,
	};
	static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_tunnelbroker_2eproto_once;
	const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tunnelbroker_2eproto = {
	- false, false, 1652, descriptor_table_protodef_tunnelbroker_2eproto, "tunnelbroker.proto",
	- &descriptor_table_tunnelbroker_2eproto_once, descriptor_table_tunnelbroker_2eproto_deps, 1, 12,
	+ false, false, 1912, descriptor_table_protodef_tunnelbroker_2eproto, "tunnelbroker.proto",
	+ &descriptor_table_tunnelbroker_2eproto_once, descriptor_table_tunnelbroker_2eproto_deps, 1, 14,
	schemas, file_default_instances, TableStruct_tunnelbroker_2eproto::offsets,
	file_level_metadata_tunnelbroker_2eproto, file_level_enum_descriptors_tunnelbroker_2eproto, file_level_service_descriptors_tunnelbroker_2eproto,
	};
	@@ -937,11 +993,12 @@
	CHK_(ptr);
	} else goto handle_unusual;
	continue;
	- // bytes publicKey = 2;
	+ // string publicKey = 2;
	case 2:
	if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	auto str = _internal_mutable_publickey();
	ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewSessionRequest.publicKey"));
	CHK_(ptr);
	} else goto handle_unusual;
	continue;
	@@ -1028,9 +1085,13 @@
	1, this->_internal_deviceid(), target);
	}

	- // bytes publicKey = 2;
	+ // string publicKey = 2;
	if (this->publickey().size() > 0) {
	- target = stream->WriteBytesMaybeAliased(
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_publickey().data(), static_cast<int>(this->_internal_publickey().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "tunnelbroker.NewSessionRequest.publicKey");
	+ target = stream->WriteStringMaybeAliased(
	2, this->_internal_publickey(), target);
	}

	@@ -1104,10 +1165,10 @@
	this->_internal_deviceid());
	}

	- // bytes publicKey = 2;
	+ // string publicKey = 2;
	if (this->publickey().size() > 0) {
	total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	this->_internal_publickey());
	}

	@@ -2214,6 +2275,594 @@
	}


	+// ===================================================================
	+
	+class OutboundMessage::_Internal {
	+ public:
	+};
	+
	+OutboundMessage::OutboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena),
	+ blobhashes_(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:tunnelbroker.OutboundMessage)
	+}
	+OutboundMessage::OutboundMessage(const OutboundMessage& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(),
	+ blobhashes_(from.blobhashes_) {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_todeviceid().empty()) {
	+ todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_todeviceid(),
	+ GetArena());
	+ }
	+ payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_payload().empty()) {
	+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(),
	+ GetArena());
	+ }
	+ // @@protoc_insertion_point(copy_constructor:tunnelbroker.OutboundMessage)
	+}
	+
	+void OutboundMessage::SharedCtor() {
	+todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+OutboundMessage::~OutboundMessage() {
	+ // @@protoc_insertion_point(destructor:tunnelbroker.OutboundMessage)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void OutboundMessage::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ todeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+void OutboundMessage::ArenaDtor(void* object) {
	+ OutboundMessage* _this = reinterpret_cast< OutboundMessage* >(object);
	+ (void)_this;
	+}
	+void OutboundMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void OutboundMessage::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void OutboundMessage::Clear() {
	+// @@protoc_insertion_point(message_clear_start:tunnelbroker.OutboundMessage)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ blobhashes_.Clear();
	+ todeviceid_.ClearToEmpty();
	+ payload_.ClearToEmpty();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* OutboundMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	+ while (!ctx->Done(&ptr)) {
	+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	+ CHK_(ptr);
	+ switch (tag >> 3) {
	+ // string toDeviceID = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ auto str = _internal_mutable_todeviceid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.toDeviceID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string payload = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_payload();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.payload"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // repeated string blobHashes = 3;
	+ case 3:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ ptr -= 1;
	+ do {
	+ ptr += 1;
	+ auto str = _internal_add_blobhashes();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.blobHashes"));
	+ CHK_(ptr);
	+ if (!ctx->DataAvailable(ptr)) break;
	+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
	+ } else goto handle_unusual;
	+ continue;
	+ default: {
	+ handle_unusual:
	+ if ((tag & 7) == 4 \|\| tag == 0) {
	+ ctx->SetLastTag(tag);
	+ goto success;
	+ }
	+ ptr = UnknownFieldParse(tag,
	+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
	+ ptr, ctx);
	+ CHK_(ptr != nullptr);
	+ continue;
	+ }
	+ } // switch
	+ } // while
	+success:
	+ return ptr;
	+failure:
	+ ptr = nullptr;
	+ goto success;
	+#undef CHK_
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::uint8* OutboundMessage::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.OutboundMessage)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // string toDeviceID = 1;
	+ if (this->todeviceid().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_todeviceid().data(), static_cast<int>(this->_internal_todeviceid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "tunnelbroker.OutboundMessage.toDeviceID");
	+ target = stream->WriteStringMaybeAliased(
	+ 1, this->_internal_todeviceid(), target);
	+ }
	+
	+ // string payload = 2;
	+ if (this->payload().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_payload().data(), static_cast<int>(this->_internal_payload().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "tunnelbroker.OutboundMessage.payload");
	+ target = stream->WriteStringMaybeAliased(
	+ 2, this->_internal_payload(), target);
	+ }
	+
	+ // repeated string blobHashes = 3;
	+ for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) {
	+ const auto& s = this->_internal_blobhashes(i);
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ s.data(), static_cast<int>(s.length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "tunnelbroker.OutboundMessage.blobHashes");
	+ target = stream->WriteString(3, s, target);
	+ }
	+
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	+ }
	+ // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.OutboundMessage)
	+ return target;
	+}
	+
	+size_t OutboundMessage::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.OutboundMessage)
	+ size_t total_size = 0;
	+
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ // repeated string blobHashes = 3;
	+ total_size += 1 *
	+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size());
	+ for (int i = 0, n = blobhashes_.size(); i < n; i++) {
	+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ blobhashes_.Get(i));
	+ }
	+
	+ // string toDeviceID = 1;
	+ if (this->todeviceid().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_todeviceid());
	+ }
	+
	+ // string payload = 2;
	+ if (this->payload().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_payload());
	+ }
	+
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
	+ _internal_metadata_, total_size, &_cached_size_);
	+ }
	+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
	+ SetCachedSize(cached_size);
	+ return total_size;
	+}
	+
	+void OutboundMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.OutboundMessage)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const OutboundMessage* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<OutboundMessage>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.OutboundMessage)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.OutboundMessage)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void OutboundMessage::MergeFrom(const OutboundMessage& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.OutboundMessage)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ blobhashes_.MergeFrom(from.blobhashes_);
	+ if (from.todeviceid().size() > 0) {
	+ _internal_set_todeviceid(from._internal_todeviceid());
	+ }
	+ if (from.payload().size() > 0) {
	+ _internal_set_payload(from._internal_payload());
	+ }
	+}
	+
	+void OutboundMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.OutboundMessage)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void OutboundMessage::CopyFrom(const OutboundMessage& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.OutboundMessage)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool OutboundMessage::IsInitialized() const {
	+ return true;
	+}
	+
	+void OutboundMessage::InternalSwap(OutboundMessage* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ blobhashes_.InternalSwap(&other->blobhashes_);
	+ todeviceid_.Swap(&other->todeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata OutboundMessage::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class InboundMessage::_Internal {
	+ public:
	+};
	+
	+InboundMessage::InboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena),
	+ blobhashes_(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:tunnelbroker.InboundMessage)
	+}
	+InboundMessage::InboundMessage(const InboundMessage& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(),
	+ blobhashes_(from.blobhashes_) {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_fromdeviceid().empty()) {
	+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromdeviceid(),
	+ GetArena());
	+ }
	+ fromconnectionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_fromconnectionid().empty()) {
	+ fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromconnectionid(),
	+ GetArena());
	+ }
	+ payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_payload().empty()) {
	+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(),
	+ GetArena());
	+ }
	+ // @@protoc_insertion_point(copy_constructor:tunnelbroker.InboundMessage)
	+}
	+
	+void InboundMessage::SharedCtor() {
	+fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+fromconnectionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+InboundMessage::~InboundMessage() {
	+ // @@protoc_insertion_point(destructor:tunnelbroker.InboundMessage)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void InboundMessage::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ fromdeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ fromconnectionid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+void InboundMessage::ArenaDtor(void* object) {
	+ InboundMessage* _this = reinterpret_cast< InboundMessage* >(object);
	+ (void)_this;
	+}
	+void InboundMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void InboundMessage::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void InboundMessage::Clear() {
	+// @@protoc_insertion_point(message_clear_start:tunnelbroker.InboundMessage)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ blobhashes_.Clear();
	+ fromdeviceid_.ClearToEmpty();
	+ fromconnectionid_.ClearToEmpty();
	+ payload_.ClearToEmpty();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* InboundMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
	+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
	+ while (!ctx->Done(&ptr)) {
	+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
	+ CHK_(ptr);
	+ switch (tag >> 3) {
	+ // string fromDeviceID = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ auto str = _internal_mutable_fromdeviceid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.fromDeviceID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string fromConnectionID = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_fromconnectionid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.fromConnectionID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string payload = 3;
	+ case 3:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ auto str = _internal_mutable_payload();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.payload"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // repeated string blobHashes = 4;
	+ case 4:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
	+ ptr -= 1;
	+ do {
	+ ptr += 1;
	+ auto str = _internal_add_blobhashes();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.blobHashes"));
	+ CHK_(ptr);
	+ if (!ctx->DataAvailable(ptr)) break;
	+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
	+ } else goto handle_unusual;
	+ continue;
	+ default: {
	+ handle_unusual:
	+ if ((tag & 7) == 4 \|\| tag == 0) {
	+ ctx->SetLastTag(tag);
	+ goto success;
	+ }
	+ ptr = UnknownFieldParse(tag,
	+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
	+ ptr, ctx);
	+ CHK_(ptr != nullptr);
	+ continue;
	+ }
	+ } // switch
	+ } // while
	+success:
	+ return ptr;
	+failure:
	+ ptr = nullptr;
	+ goto success;
	+#undef CHK_
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::uint8* InboundMessage::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.InboundMessage)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // string fromDeviceID = 1;
	+ if (this->fromdeviceid().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_fromdeviceid().data(), static_cast<int>(this->_internal_fromdeviceid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "tunnelbroker.InboundMessage.fromDeviceID");
	+ target = stream->WriteStringMaybeAliased(
	+ 1, this->_internal_fromdeviceid(), target);
	+ }
	+
	+ // string fromConnectionID = 2;
	+ if (this->fromconnectionid().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_fromconnectionid().data(), static_cast<int>(this->_internal_fromconnectionid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "tunnelbroker.InboundMessage.fromConnectionID");
	+ target = stream->WriteStringMaybeAliased(
	+ 2, this->_internal_fromconnectionid(), target);
	+ }
	+
	+ // string payload = 3;
	+ if (this->payload().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_payload().data(), static_cast<int>(this->_internal_payload().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "tunnelbroker.InboundMessage.payload");
	+ target = stream->WriteStringMaybeAliased(
	+ 3, this->_internal_payload(), target);
	+ }
	+
	+ // repeated string blobHashes = 4;
	+ for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) {
	+ const auto& s = this->_internal_blobhashes(i);
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ s.data(), static_cast<int>(s.length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "tunnelbroker.InboundMessage.blobHashes");
	+ target = stream->WriteString(4, s, target);
	+ }
	+
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
	+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
	+ }
	+ // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.InboundMessage)
	+ return target;
	+}
	+
	+size_t InboundMessage::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.InboundMessage)
	+ size_t total_size = 0;
	+
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ // repeated string blobHashes = 4;
	+ total_size += 1 *
	+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size());
	+ for (int i = 0, n = blobhashes_.size(); i < n; i++) {
	+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ blobhashes_.Get(i));
	+ }
	+
	+ // string fromDeviceID = 1;
	+ if (this->fromdeviceid().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_fromdeviceid());
	+ }
	+
	+ // string fromConnectionID = 2;
	+ if (this->fromconnectionid().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_fromconnectionid());
	+ }
	+
	+ // string payload = 3;
	+ if (this->payload().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_payload());
	+ }
	+
	+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
	+ _internal_metadata_, total_size, &_cached_size_);
	+ }
	+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
	+ SetCachedSize(cached_size);
	+ return total_size;
	+}
	+
	+void InboundMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.InboundMessage)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const InboundMessage* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<InboundMessage>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.InboundMessage)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.InboundMessage)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void InboundMessage::MergeFrom(const InboundMessage& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.InboundMessage)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ blobhashes_.MergeFrom(from.blobhashes_);
	+ if (from.fromdeviceid().size() > 0) {
	+ _internal_set_fromdeviceid(from._internal_fromdeviceid());
	+ }
	+ if (from.fromconnectionid().size() > 0) {
	+ _internal_set_fromconnectionid(from._internal_fromconnectionid());
	+ }
	+ if (from.payload().size() > 0) {
	+ _internal_set_payload(from._internal_payload());
	+ }
	+}
	+
	+void InboundMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.InboundMessage)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void InboundMessage::CopyFrom(const InboundMessage& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.InboundMessage)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool InboundMessage::IsInitialized() const {
	+ return true;
	+}
	+
	+void InboundMessage::InternalSwap(InboundMessage* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ blobhashes_.InternalSwap(&other->blobhashes_);
	+ fromdeviceid_.Swap(&other->fromdeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ fromconnectionid_.Swap(&other->fromconnectionid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata InboundMessage::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	// ===================================================================

	class CheckRequest::_Internal {
	@@ -3329,6 +3978,12 @@
	template<> PROTOBUF_NOINLINE ::tunnelbroker::GetResponse* Arena::CreateMaybeMessage< ::tunnelbroker::GetResponse >(Arena* arena) {
	return Arena::CreateMessageInternal< ::tunnelbroker::GetResponse >(arena);
	}
	+template<> PROTOBUF_NOINLINE ::tunnelbroker::OutboundMessage* Arena::CreateMaybeMessage< ::tunnelbroker::OutboundMessage >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::tunnelbroker::OutboundMessage >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::tunnelbroker::InboundMessage* Arena::CreateMaybeMessage< ::tunnelbroker::InboundMessage >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::tunnelbroker::InboundMessage >(arena);
	+}
	template<> PROTOBUF_NOINLINE ::tunnelbroker::CheckRequest* Arena::CreateMaybeMessage< ::tunnelbroker::CheckRequest >(Arena* arena) {
	return Arena::CreateMessageInternal< ::tunnelbroker::CheckRequest >(arena);
	}
	diff --git a/native/cpp/CommonCpp/grpc/protos/backup.proto b/native/cpp/CommonCpp/grpc/protos/backup.proto
	--- a/native/cpp/CommonCpp/grpc/protos/backup.proto
	+++ b/native/cpp/CommonCpp/grpc/protos/backup.proto
	@@ -5,48 +5,93 @@
	import "google/protobuf/empty.proto";

	service BackupService {
	- rpc ResetKey(stream ResetKeyRequest) returns (google.protobuf.Empty) {}
	- rpc SendLog(SendLogRequest) returns (google.protobuf.Empty) {}
	- rpc PullBackupKey(PullBackupKeyRequest) returns (PullBackupKeyResponse) {}
	- rpc PullCompaction(PullCompactionRequest) returns (stream PullCompactionResponse) {}
	+ rpc CreateNewBackup(stream CreateNewBackupRequest) returns (stream CreateNewBackupResponse) {}
	+ rpc SendLog(stream SendLogRequest) returns (google.protobuf.Empty) {}
	+ rpc RecoverBackupKey(stream RecoverBackupKeyRequest) returns (stream RecoverBackupKeyResponse) {}
	+ rpc PullBackup(stream PullBackupRequest) returns (stream PullBackupResponse) {}
	}

	-// ResetKey
	+// Helper types

	-message ResetKeyRequest {
	- string userId = 1;
	+message FullAuthenticationRequestData {
	+ oneof requestBytes {
	+ bytes pakeRegistrationRequest = 1;
	+ bytes pakeRegistrationUpload = 2;
	+ bytes pakeCredentialRequest = 3;
	+ bytes pakeCredentialFinalization = 4;
	+ bytes pakeChallengeResponse = 5;
	+ bytes walletAuthenticationRequest = 6;
	+ }
	+ string userID = 7;
	+}
	+
	+message FullAuthenticationResponseData {
	+ oneof responseData {
	+ bytes pakeRegistrationResponse = 1;
	+ bool pakeRegistrationSuccess = 2;
	+ bytes pakeCredentialResponse = 3;
	+ bytes pakeChallengeMessage = 4;
	+ bytes walletAuthenticationResponse = 5;
	+ }
	+}
	+
	+message SimpleAuthenticationRequestData {
	+ string backupID = 1;
	+ string userID = 2;
	+}
	+
	+message AuthenticationInformationData {
	oneof data {
	- bytes newKey = 2;
	- bytes compactionChunk = 3;
	+ bytes nonce = 1;
	+ bytes rawMessage = 2;
	+ }
	+}
	+
	+// CreateNewBackup
	+
	+message CreateNewBackupRequest {
	+ oneof data {
	+ FullAuthenticationRequestData authenticationRequestData = 1;
	+ AuthenticationInformationData authenticationInformationData = 2;
	+ bytes newCompactionChunk = 3;
	+ }
	+}
	+
	+message CreateNewBackupResponse {
	+ oneof data {
	+ FullAuthenticationResponseData authenticationResponseData = 1;
	+ string backupID = 2;
	}
	}

	// SendLog

	message SendLogRequest {
	- string userId = 1;
	- bytes data = 2;
	+ SimpleAuthenticationRequestData authenticationData = 1;
	+ bytes logData = 2;
	}

	-// PullBackupKey
	+// RecoverBackupKey

	-message PullBackupKeyRequest {
	- string userId = 1;
	- bytes pakeKey = 2;
	+message RecoverBackupKeyRequest {
	+ FullAuthenticationRequestData authenticationData = 1;
	}

	-message PullBackupKeyResponse {
	- bytes encryptedBackupKey = 1;
	+message RecoverBackupKeyResponse {
	+ oneof data {
	+ FullAuthenticationResponseData authenticationResponseData = 1;
	+ AuthenticationInformationData authenticationInformationData = 2;
	+ string backupID = 3;
	+ }
	}

	-// PullCompaction
	+// PullBackup

	-message PullCompactionRequest {
	- string userId = 1;
	- bytes message = 2;
	+message PullBackupRequest {
	+ SimpleAuthenticationRequestData authenticationData = 1;
	}

	-message PullCompactionResponse {
	+message PullBackupResponse {
	oneof data {
	bytes compactionChunk = 1;
	bytes logChunk = 2;

File Metadata

Mime Type: text/plain
Expires: Mon, Dec 8, 8:30 PM (8 h, 39 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5850479
Default Alt Text: D3076.1765225844.diff (739 KB)

D3076.1765225844.diffNo OneTemporaryActions

D3076.1765225844.diffView Options

File Metadata

Event Timeline

D3076.1765225844.diff
No OneTemporary
Actions

D3076.1765225844.diff
View Options