D4546.id.diff
No OneTemporary
Actions

Size

445 KB

Referenced Files

None

Subscribers

None

D4546.id.diff
View Options

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

	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
	@@ -1373,9 +1373,16 @@
	static const PullBackupResponse& default_instance() {
	return *internal_default_instance();
	}
	+ enum IdCase {
	+ kBackupID = 4,
	+ kLogID = 5,
	+ ID_NOT_SET = 0,
	+ };
	+
	enum DataCase {
	kCompactionChunk = 1,
	kLogChunk = 2,
	+ kAttachmentHolders = 3,
	DATA_NOT_SET = 0,
	};

	@@ -1454,17 +1461,50 @@
	// accessors -------------------------------------------------------

	enum : int {
	- kChunkCounterFieldNumber = 3,
	+ kBackupIDFieldNumber = 4,
	+ kLogIDFieldNumber = 5,
	kCompactionChunkFieldNumber = 1,
	kLogChunkFieldNumber = 2,
	+ kAttachmentHoldersFieldNumber = 3,
	};
	- // int32 chunkCounter = 3;
	- void clear_chunkcounter();
	- ::PROTOBUF_NAMESPACE_ID::int32 chunkcounter() const;
	- void set_chunkcounter(::PROTOBUF_NAMESPACE_ID::int32 value);
	+ // string backupID = 4;
	+ 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:
	- ::PROTOBUF_NAMESPACE_ID::int32 _internal_chunkcounter() const;
	- void _internal_set_chunkcounter(::PROTOBUF_NAMESPACE_ID::int32 value);
	+ const std::string& _internal_backupid() const;
	+ void _internal_set_backupid(const std::string& value);
	+ std::string* _internal_mutable_backupid();
	+ public:
	+
	+ // string logID = 5;
	+ bool has_logid() const;
	+ private:
	+ bool _internal_has_logid() const;
	+ public:
	+ void clear_logid();
	+ const std::string& logid() const;
	+ void set_logid(const std::string& value);
	+ void set_logid(std::string&& value);
	+ void set_logid(const char* value);
	+ void set_logid(const char* value, size_t size);
	+ std::string* mutable_logid();
	+ std::string* release_logid();
	+ void set_allocated_logid(std::string* logid);
	+ private:
	+ const std::string& _internal_logid() const;
	+ void _internal_set_logid(const std::string& value);
	+ std::string* _internal_mutable_logid();
	public:

	// bytes compactionChunk = 1;
	@@ -1507,13 +1547,41 @@
	std::string* _internal_mutable_logchunk();
	public:

	+ // string attachmentHolders = 3;
	+ bool has_attachmentholders() const;
	+ private:
	+ bool _internal_has_attachmentholders() const;
	+ public:
	+ void clear_attachmentholders();
	+ const std::string& attachmentholders() const;
	+ void set_attachmentholders(const std::string& value);
	+ void set_attachmentholders(std::string&& value);
	+ void set_attachmentholders(const char* value);
	+ void set_attachmentholders(const char* value, size_t size);
	+ std::string* mutable_attachmentholders();
	+ std::string* release_attachmentholders();
	+ void set_allocated_attachmentholders(std::string* attachmentholders);
	+ private:
	+ const std::string& _internal_attachmentholders() const;
	+ void _internal_set_attachmentholders(const std::string& value);
	+ std::string* _internal_mutable_attachmentholders();
	+ public:
	+
	+ void clear_id();
	+ IdCase id_case() const;
	void clear_data();
	DataCase data_case() const;
	// @@protoc_insertion_point(class_scope:backup.PullBackupResponse)
	private:
	class _Internal;
	+ void set_has_backupid();
	+ void set_has_logid();
	void set_has_compactionchunk();
	void set_has_logchunk();
	+ void set_has_attachmentholders();
	+
	+ inline bool has_id() const;
	+ inline void clear_has_id();

	inline bool has_data() const;
	inline void clear_has_data();
	@@ -1521,15 +1589,21 @@
	template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	typedef void InternalArenaConstructable_;
	typedef void DestructorSkippable_;
	- ::PROTOBUF_NAMESPACE_ID::int32 chunkcounter_;
	+ union IdUnion {
	+ constexpr IdUnion() : _constinit_{} {}
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logid_;
	+ } id_;
	union DataUnion {
	constexpr DataUnion() : _constinit_{} {}
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_;
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logchunk_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentholders_;
	} data_;
	mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	- ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2];

	friend struct ::TableStruct_backup_2eproto;
	};
	@@ -3144,6 +3218,226 @@

	// PullBackupResponse

	+// string backupID = 4;
	+inline bool PullBackupResponse::_internal_has_backupid() const {
	+ return id_case() == kBackupID;
	+}
	+inline bool PullBackupResponse::has_backupid() const {
	+ return _internal_has_backupid();
	+}
	+inline void PullBackupResponse::set_has_backupid() {
	+ _oneof_case_[0] = kBackupID;
	+}
	+inline void PullBackupResponse::clear_backupid() {
	+ if (_internal_has_backupid()) {
	+ id_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_id();
	+ }
	+}
	+inline const std::string& PullBackupResponse::backupid() const {
	+ // @@protoc_insertion_point(field_get:backup.PullBackupResponse.backupID)
	+ return _internal_backupid();
	+}
	+inline void PullBackupResponse::set_backupid(const std::string& value) {
	+ _internal_set_backupid(value);
	+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.backupID)
	+}
	+inline std::string* PullBackupResponse::mutable_backupid() {
	+ // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.backupID)
	+ return _internal_mutable_backupid();
	+}
	+inline const std::string& PullBackupResponse::_internal_backupid() const {
	+ if (_internal_has_backupid()) {
	+ return id_.backupid_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void PullBackupResponse::_internal_set_backupid(const std::string& value) {
	+ if (!_internal_has_backupid()) {
	+ clear_id();
	+ set_has_backupid();
	+ id_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ id_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PullBackupResponse::set_backupid(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.backupID)
	+ if (!_internal_has_backupid()) {
	+ clear_id();
	+ set_has_backupid();
	+ id_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ id_.backupid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.backupID)
	+}
	+inline void PullBackupResponse::set_backupid(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_backupid()) {
	+ clear_id();
	+ set_has_backupid();
	+ id_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ id_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.backupID)
	+}
	+inline void PullBackupResponse::set_backupid(const char* value,
	+ size_t size) {
	+ if (!_internal_has_backupid()) {
	+ clear_id();
	+ set_has_backupid();
	+ id_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ id_.backupid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.backupID)
	+}
	+inline std::string* PullBackupResponse::_internal_mutable_backupid() {
	+ if (!_internal_has_backupid()) {
	+ clear_id();
	+ set_has_backupid();
	+ id_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return id_.backupid_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PullBackupResponse::release_backupid() {
	+ // @@protoc_insertion_point(field_release:backup.PullBackupResponse.backupID)
	+ if (_internal_has_backupid()) {
	+ clear_has_id();
	+ return id_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void PullBackupResponse::set_allocated_backupid(std::string* backupid) {
	+ if (has_id()) {
	+ clear_id();
	+ }
	+ if (backupid != nullptr) {
	+ set_has_backupid();
	+ id_.backupid_.UnsafeSetDefault(backupid);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(backupid);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.backupID)
	+}
	+
	+// string logID = 5;
	+inline bool PullBackupResponse::_internal_has_logid() const {
	+ return id_case() == kLogID;
	+}
	+inline bool PullBackupResponse::has_logid() const {
	+ return _internal_has_logid();
	+}
	+inline void PullBackupResponse::set_has_logid() {
	+ _oneof_case_[0] = kLogID;
	+}
	+inline void PullBackupResponse::clear_logid() {
	+ if (_internal_has_logid()) {
	+ id_.logid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_id();
	+ }
	+}
	+inline const std::string& PullBackupResponse::logid() const {
	+ // @@protoc_insertion_point(field_get:backup.PullBackupResponse.logID)
	+ return _internal_logid();
	+}
	+inline void PullBackupResponse::set_logid(const std::string& value) {
	+ _internal_set_logid(value);
	+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.logID)
	+}
	+inline std::string* PullBackupResponse::mutable_logid() {
	+ // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.logID)
	+ return _internal_mutable_logid();
	+}
	+inline const std::string& PullBackupResponse::_internal_logid() const {
	+ if (_internal_has_logid()) {
	+ return id_.logid_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void PullBackupResponse::_internal_set_logid(const std::string& value) {
	+ if (!_internal_has_logid()) {
	+ clear_id();
	+ set_has_logid();
	+ id_.logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ id_.logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PullBackupResponse::set_logid(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.logID)
	+ if (!_internal_has_logid()) {
	+ clear_id();
	+ set_has_logid();
	+ id_.logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ id_.logid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.logID)
	+}
	+inline void PullBackupResponse::set_logid(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_logid()) {
	+ clear_id();
	+ set_has_logid();
	+ id_.logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ id_.logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.logID)
	+}
	+inline void PullBackupResponse::set_logid(const char* value,
	+ size_t size) {
	+ if (!_internal_has_logid()) {
	+ clear_id();
	+ set_has_logid();
	+ id_.logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ id_.logid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.logID)
	+}
	+inline std::string* PullBackupResponse::_internal_mutable_logid() {
	+ if (!_internal_has_logid()) {
	+ clear_id();
	+ set_has_logid();
	+ id_.logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return id_.logid_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PullBackupResponse::release_logid() {
	+ // @@protoc_insertion_point(field_release:backup.PullBackupResponse.logID)
	+ if (_internal_has_logid()) {
	+ clear_has_id();
	+ return id_.logid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void PullBackupResponse::set_allocated_logid(std::string* logid) {
	+ if (has_id()) {
	+ clear_id();
	+ }
	+ if (logid != nullptr) {
	+ set_has_logid();
	+ id_.logid_.UnsafeSetDefault(logid);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(logid);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.logID)
	+}
	+
	// bytes compactionChunk = 1;
	inline bool PullBackupResponse::_internal_has_compactionchunk() const {
	return data_case() == kCompactionChunk;
	@@ -3152,7 +3446,7 @@
	return _internal_has_compactionchunk();
	}
	inline void PullBackupResponse::set_has_compactionchunk() {
	- _oneof_case_[0] = kCompactionChunk;
	+ _oneof_case_[1] = kCompactionChunk;
	}
	inline void PullBackupResponse::clear_compactionchunk() {
	if (_internal_has_compactionchunk()) {
	@@ -3262,7 +3556,7 @@
	return _internal_has_logchunk();
	}
	inline void PullBackupResponse::set_has_logchunk() {
	- _oneof_case_[0] = kLogChunk;
	+ _oneof_case_[1] = kLogChunk;
	}
	inline void PullBackupResponse::clear_logchunk() {
	if (_internal_has_logchunk()) {
	@@ -3364,34 +3658,133 @@
	// @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.logChunk)
	}

	-// int32 chunkCounter = 3;
	-inline void PullBackupResponse::clear_chunkcounter() {
	- chunkcounter_ = 0;
	+// string attachmentHolders = 3;
	+inline bool PullBackupResponse::_internal_has_attachmentholders() const {
	+ return data_case() == kAttachmentHolders;
	}
	-inline ::PROTOBUF_NAMESPACE_ID::int32 PullBackupResponse::_internal_chunkcounter() const {
	- return chunkcounter_;
	+inline bool PullBackupResponse::has_attachmentholders() const {
	+ return _internal_has_attachmentholders();
	}
	-inline ::PROTOBUF_NAMESPACE_ID::int32 PullBackupResponse::chunkcounter() const {
	- // @@protoc_insertion_point(field_get:backup.PullBackupResponse.chunkCounter)
	- return _internal_chunkcounter();
	+inline void PullBackupResponse::set_has_attachmentholders() {
	+ _oneof_case_[1] = kAttachmentHolders;
	}
	-inline void PullBackupResponse::_internal_set_chunkcounter(::PROTOBUF_NAMESPACE_ID::int32 value) {
	-
	- chunkcounter_ = value;
	+inline void PullBackupResponse::clear_attachmentholders() {
	+ if (_internal_has_attachmentholders()) {
	+ data_.attachmentholders_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_data();
	+ }
	+}
	+inline const std::string& PullBackupResponse::attachmentholders() const {
	+ // @@protoc_insertion_point(field_get:backup.PullBackupResponse.attachmentHolders)
	+ return _internal_attachmentholders();
	+}
	+inline void PullBackupResponse::set_attachmentholders(const std::string& value) {
	+ _internal_set_attachmentholders(value);
	+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.attachmentHolders)
	+}
	+inline std::string* PullBackupResponse::mutable_attachmentholders() {
	+ // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.attachmentHolders)
	+ return _internal_mutable_attachmentholders();
	+}
	+inline const std::string& PullBackupResponse::_internal_attachmentholders() const {
	+ if (_internal_has_attachmentholders()) {
	+ return data_.attachmentholders_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void PullBackupResponse::_internal_set_attachmentholders(const std::string& value) {
	+ if (!_internal_has_attachmentholders()) {
	+ clear_data();
	+ set_has_attachmentholders();
	+ data_.attachmentholders_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.attachmentholders_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PullBackupResponse::set_attachmentholders(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.attachmentHolders)
	+ if (!_internal_has_attachmentholders()) {
	+ clear_data();
	+ set_has_attachmentholders();
	+ data_.attachmentholders_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.attachmentholders_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.attachmentHolders)
	+}
	+inline void PullBackupResponse::set_attachmentholders(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_attachmentholders()) {
	+ clear_data();
	+ set_has_attachmentholders();
	+ data_.attachmentholders_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.attachmentholders_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.attachmentHolders)
	+}
	+inline void PullBackupResponse::set_attachmentholders(const char* value,
	+ size_t size) {
	+ if (!_internal_has_attachmentholders()) {
	+ clear_data();
	+ set_has_attachmentholders();
	+ data_.attachmentholders_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.attachmentholders_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.attachmentHolders)
	}
	-inline void PullBackupResponse::set_chunkcounter(::PROTOBUF_NAMESPACE_ID::int32 value) {
	- _internal_set_chunkcounter(value);
	- // @@protoc_insertion_point(field_set:backup.PullBackupResponse.chunkCounter)
	+inline std::string* PullBackupResponse::_internal_mutable_attachmentholders() {
	+ if (!_internal_has_attachmentholders()) {
	+ clear_data();
	+ set_has_attachmentholders();
	+ data_.attachmentholders_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return data_.attachmentholders_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PullBackupResponse::release_attachmentholders() {
	+ // @@protoc_insertion_point(field_release:backup.PullBackupResponse.attachmentHolders)
	+ if (_internal_has_attachmentholders()) {
	+ clear_has_data();
	+ return data_.attachmentholders_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void PullBackupResponse::set_allocated_attachmentholders(std::string* attachmentholders) {
	+ if (has_data()) {
	+ clear_data();
	+ }
	+ if (attachmentholders != nullptr) {
	+ set_has_attachmentholders();
	+ data_.attachmentholders_.UnsafeSetDefault(attachmentholders);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(attachmentholders);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.attachmentHolders)
	}

	+inline bool PullBackupResponse::has_id() const {
	+ return id_case() != ID_NOT_SET;
	+}
	+inline void PullBackupResponse::clear_has_id() {
	+ _oneof_case_[0] = ID_NOT_SET;
	+}
	inline bool PullBackupResponse::has_data() const {
	return data_case() != DATA_NOT_SET;
	}
	inline void PullBackupResponse::clear_has_data() {
	- _oneof_case_[0] = DATA_NOT_SET;
	+ _oneof_case_[1] = DATA_NOT_SET;
	+}
	+inline PullBackupResponse::IdCase PullBackupResponse::id_case() const {
	+ return PullBackupResponse::IdCase(_oneof_case_[0]);
	}
	inline PullBackupResponse::DataCase PullBackupResponse::data_case() const {
	- return PullBackupResponse::DataCase(_oneof_case_[0]);
	+ return PullBackupResponse::DataCase(_oneof_case_[1]);
	}
	// -------------------------------------------------------------------

	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
	@@ -104,8 +104,7 @@
	PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupRequestDefaultTypeInternal _PullBackupRequest_default_instance_;
	constexpr PullBackupResponse::PullBackupResponse(
	::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	- : chunkcounter_(0)
	- , _oneof_case_{}{}
	+ : _oneof_case_{}{}
	struct PullBackupResponseDefaultTypeInternal {
	constexpr PullBackupResponseDefaultTypeInternal()
	: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	@@ -195,7 +194,10 @@
	~0u, // no _weak_field_map_
	::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	- PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, chunkcounter_),
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, id_),
	PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, data_),
	~0u, // no _has_bits_
	PROTOBUF_FIELD_OFFSET(::backup::AddAttachmentsRequest, _internal_metadata_),
	@@ -216,7 +218,7 @@
	{ 39, -1, sizeof(::backup::RecoverBackupKeyResponse)},
	{ 45, -1, sizeof(::backup::PullBackupRequest)},
	{ 52, -1, sizeof(::backup::PullBackupResponse)},
	- { 61, -1, sizeof(::backup::AddAttachmentsRequest)},
	+ { 64, -1, sizeof(::backup::AddAttachmentsRequest)},
	};

	static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
	@@ -245,29 +247,30 @@
	"coverBackupKeyRequest\022\016\n\006userID\030\001 \001(\t\",\n"
	"\030RecoverBackupKeyResponse\022\020\n\010backupID\030\004 "
	"\001(\t\"5\n\021PullBackupRequest\022\016\n\006userID\030\001 \001(\t"
	- "\022\020\n\010backupID\030\002 \001(\t\"a\n\022PullBackupResponse"
	- "\022\031\n\017compactionChunk\030\001 \001(\014H\000\022\022\n\010logChunk\030"
	- "\002 \001(\014H\000\022\024\n\014chunkCounter\030\003 \001(\005B\006\n\004data\"Y\n"
	- "\025AddAttachmentsRequest\022\016\n\006userID\030\001 \001(\t\022\020"
	- "\n\010backupID\030\002 \001(\t\022\r\n\005logID\030\003 \001(\t\022\017\n\007holde"
	- "rs\030\004 \001(\t2\232\003\n\rBackupService\022X\n\017CreateNewB"
	- "ackup\022\036.backup.CreateNewBackupRequest\032\037."
	- "backup.CreateNewBackupResponse\"\000(\0010\001\022>\n\007"
	- "SendLog\022\026.backup.SendLogRequest\032\027.backup"
	- ".SendLogResponse\"\000(\001\022[\n\020RecoverBackupKey"
	- "\022\037.backup.RecoverBackupKeyRequest\032 .back"
	- "up.RecoverBackupKeyResponse\"\000(\0010\001\022G\n\nPul"
	- "lBackup\022\031.backup.PullBackupRequest\032\032.bac"
	- "kup.PullBackupResponse\"\0000\001\022I\n\016AddAttachm"
	- "ents\022\035.backup.AddAttachmentsRequest\032\026.go"
	- "ogle.protobuf.Empty\"\000b\006proto3"
	+ "\022\020\n\010backupID\030\002 \001(\t\"\223\001\n\022PullBackupRespons"
	+ "e\022\022\n\010backupID\030\004 \001(\tH\000\022\017\n\005logID\030\005 \001(\tH\000\022\031"
	+ "\n\017compactionChunk\030\001 \001(\014H\001\022\022\n\010logChunk\030\002 "
	+ "\001(\014H\001\022\033\n\021attachmentHolders\030\003 \001(\tH\001B\004\n\002id"
	+ "B\006\n\004data\"Y\n\025AddAttachmentsRequest\022\016\n\006use"
	+ "rID\030\001 \001(\t\022\020\n\010backupID\030\002 \001(\t\022\r\n\005logID\030\003 \001"
	+ "(\t\022\017\n\007holders\030\004 \001(\t2\232\003\n\rBackupService\022X\n"
	+ "\017CreateNewBackup\022\036.backup.CreateNewBacku"
	+ "pRequest\032\037.backup.CreateNewBackupRespons"
	+ "e\"\000(\0010\001\022>\n\007SendLog\022\026.backup.SendLogReque"
	+ "st\032\027.backup.SendLogResponse\"\000(\001\022[\n\020Recov"
	+ "erBackupKey\022\037.backup.RecoverBackupKeyReq"
	+ "uest\032 .backup.RecoverBackupKeyResponse\"\000"
	+ "(\0010\001\022G\n\nPullBackup\022\031.backup.PullBackupRe"
	+ "quest\032\032.backup.PullBackupResponse\"\0000\001\022I\n"
	+ "\016AddAttachments\022\035.backup.AddAttachmentsR"
	+ "equest\032\026.google.protobuf.Empty\"\000b\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, 1149, descriptor_table_protodef_backup_2eproto, "backup.proto",
	+ false, false, 1200, descriptor_table_protodef_backup_2eproto, "backup.proto",
	&descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 9,
	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,
	@@ -2044,7 +2047,20 @@
	PullBackupResponse::PullBackupResponse(const PullBackupResponse& from)
	: ::PROTOBUF_NAMESPACE_ID::Message() {
	_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	- chunkcounter_ = from.chunkcounter_;
	+ clear_has_id();
	+ switch (from.id_case()) {
	+ case kBackupID: {
	+ _internal_set_backupid(from._internal_backupid());
	+ break;
	+ }
	+ case kLogID: {
	+ _internal_set_logid(from._internal_logid());
	+ break;
	+ }
	+ case ID_NOT_SET: {
	+ break;
	+ }
	+ }
	clear_has_data();
	switch (from.data_case()) {
	case kCompactionChunk: {
	@@ -2055,6 +2071,10 @@
	_internal_set_logchunk(from._internal_logchunk());
	break;
	}
	+ case kAttachmentHolders: {
	+ _internal_set_attachmentholders(from._internal_attachmentholders());
	+ break;
	+ }
	case DATA_NOT_SET: {
	break;
	}
	@@ -2063,7 +2083,7 @@
	}

	void PullBackupResponse::SharedCtor() {
	-chunkcounter_ = 0;
	+clear_has_id();
	clear_has_data();
	}

	@@ -2075,6 +2095,9 @@

	void PullBackupResponse::SharedDtor() {
	GOOGLE_DCHECK(GetArena() == nullptr);
	+ if (has_id()) {
	+ clear_id();
	+ }
	if (has_data()) {
	clear_data();
	}
	@@ -2090,6 +2113,24 @@
	_cached_size_.Set(size);
	}

	+void PullBackupResponse::clear_id() {
	+// @@protoc_insertion_point(one_of_clear_start:backup.PullBackupResponse)
	+ switch (id_case()) {
	+ case kBackupID: {
	+ id_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kLogID: {
	+ id_.logid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case ID_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = ID_NOT_SET;
	+}
	+
	void PullBackupResponse::clear_data() {
	// @@protoc_insertion_point(one_of_clear_start:backup.PullBackupResponse)
	switch (data_case()) {
	@@ -2101,11 +2142,15 @@
	data_.logchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	break;
	}
	+ case kAttachmentHolders: {
	+ data_.attachmentholders_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	case DATA_NOT_SET: {
	break;
	}
	}
	- _oneof_case_[0] = DATA_NOT_SET;
	+ _oneof_case_[1] = DATA_NOT_SET;
	}


	@@ -2115,7 +2160,7 @@
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- chunkcounter_ = 0;
	+ clear_id();
	clear_data();
	_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	}
	@@ -2143,10 +2188,30 @@
	CHK_(ptr);
	} else goto handle_unusual;
	continue;
	- // int32 chunkCounter = 3;
	+ // string attachmentHolders = 3;
	case 3:
	- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
	- chunkcounter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ auto str = _internal_mutable_attachmentholders();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupResponse.attachmentHolders"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string backupID = 4;
	+ case 4:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
	+ auto str = _internal_mutable_backupid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupResponse.backupID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string logID = 5;
	+ case 5:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
	+ auto str = _internal_mutable_logid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupResponse.logID"));
	CHK_(ptr);
	} else goto handle_unusual;
	continue;
	@@ -2190,10 +2255,34 @@
	2, this->_internal_logchunk(), target);
	}

	- // int32 chunkCounter = 3;
	- if (this->chunkcounter() != 0) {
	- target = stream->EnsureSpace(target);
	- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_chunkcounter(), target);
	+ // string attachmentHolders = 3;
	+ if (_internal_has_attachmentholders()) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_attachmentholders().data(), static_cast<int>(this->_internal_attachmentholders().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "backup.PullBackupResponse.attachmentHolders");
	+ target = stream->WriteStringMaybeAliased(
	+ 3, this->_internal_attachmentholders(), target);
	+ }
	+
	+ // string backupID = 4;
	+ 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.PullBackupResponse.backupID");
	+ target = stream->WriteStringMaybeAliased(
	+ 4, this->_internal_backupid(), target);
	+ }
	+
	+ // string logID = 5;
	+ if (_internal_has_logid()) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_logid().data(), static_cast<int>(this->_internal_logid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "backup.PullBackupResponse.logID");
	+ target = stream->WriteStringMaybeAliased(
	+ 5, this->_internal_logid(), target);
	}

	if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
	@@ -2212,13 +2301,25 @@
	// Prevent compiler warnings about cached_has_bits being unused
	(void) cached_has_bits;

	- // int32 chunkCounter = 3;
	- if (this->chunkcounter() != 0) {
	- total_size += 1 +
	- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
	- this->_internal_chunkcounter());
	+ switch (id_case()) {
	+ // string backupID = 4;
	+ case kBackupID: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_backupid());
	+ break;
	+ }
	+ // string logID = 5;
	+ case kLogID: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_logid());
	+ break;
	+ }
	+ case ID_NOT_SET: {
	+ break;
	+ }
	}
	-
	switch (data_case()) {
	// bytes compactionChunk = 1;
	case kCompactionChunk: {
	@@ -2234,6 +2335,13 @@
	this->_internal_logchunk());
	break;
	}
	+ // string attachmentHolders = 3;
	+ case kAttachmentHolders: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_attachmentholders());
	+ break;
	+ }
	case DATA_NOT_SET: {
	break;
	}
	@@ -2269,8 +2377,18 @@
	::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	(void) cached_has_bits;

	- if (from.chunkcounter() != 0) {
	- _internal_set_chunkcounter(from._internal_chunkcounter());
	+ switch (from.id_case()) {
	+ case kBackupID: {
	+ _internal_set_backupid(from._internal_backupid());
	+ break;
	+ }
	+ case kLogID: {
	+ _internal_set_logid(from._internal_logid());
	+ break;
	+ }
	+ case ID_NOT_SET: {
	+ break;
	+ }
	}
	switch (from.data_case()) {
	case kCompactionChunk: {
	@@ -2281,6 +2399,10 @@
	_internal_set_logchunk(from._internal_logchunk());
	break;
	}
	+ case kAttachmentHolders: {
	+ _internal_set_attachmentholders(from._internal_attachmentholders());
	+ break;
	+ }
	case DATA_NOT_SET: {
	break;
	}
	@@ -2308,9 +2430,10 @@
	void PullBackupResponse::InternalSwap(PullBackupResponse* other) {
	using std::swap;
	_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	- swap(chunkcounter_, other->chunkcounter_);
	+ swap(id_, other->id_);
	swap(data_, other->data_);
	swap(_oneof_case_[0], other->_oneof_case_[0]);
	+ swap(_oneof_case_[1], other->_oneof_case_[1]);
	}

	::PROTOBUF_NAMESPACE_ID::Metadata PullBackupResponse::GetMetadata() const {
	diff --git a/native/cpp/CommonCpp/grpc/_generated/identity.grpc.pb.h b/native/cpp/CommonCpp/grpc/_generated/identity.grpc.pb.h
	new file mode 100644
	--- /dev/null
	+++ b/native/cpp/CommonCpp/grpc/_generated/identity.grpc.pb.h
	@@ -0,0 +1,511 @@
	+// @generated by the gRPC C++ plugin.
	+// If you make any local change, they will be lost.
	+// source: identity.proto
	+#ifndef GRPC_identity_2eproto__INCLUDED
	+#define GRPC_identity_2eproto__INCLUDED
	+
	+#include "identity.pb.h"
	+
	+#include <functional>
	+#include <grpcpp/impl/codegen/async_generic_service.h>
	+#include <grpcpp/impl/codegen/async_stream.h>
	+#include <grpcpp/impl/codegen/async_unary_call.h>
	+#include <grpcpp/impl/codegen/client_callback.h>
	+#include <grpcpp/impl/codegen/client_context.h>
	+#include <grpcpp/impl/codegen/completion_queue.h>
	+#include <grpcpp/impl/codegen/message_allocator.h>
	+#include <grpcpp/impl/codegen/method_handler.h>
	+#include <grpcpp/impl/codegen/proto_utils.h>
	+#include <grpcpp/impl/codegen/rpc_method.h>
	+#include <grpcpp/impl/codegen/server_callback.h>
	+#include <grpcpp/impl/codegen/server_callback_handlers.h>
	+#include <grpcpp/impl/codegen/server_context.h>
	+#include <grpcpp/impl/codegen/service_type.h>
	+#include <grpcpp/impl/codegen/status.h>
	+#include <grpcpp/impl/codegen/stub_options.h>
	+#include <grpcpp/impl/codegen/sync_stream.h>
	+
	+namespace identity {
	+
	+class IdentityService final {
	+ public:
	+ static constexpr char const* service_full_name() {
	+ return "identity.IdentityService";
	+ }
	+ class StubInterface {
	+ public:
	+ virtual ~StubInterface() {}
	+ // Called by user to register with the Identity Service (PAKE only)
	+ std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> RegisterUser(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(RegisterUserRaw(context));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> AsyncRegisterUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(AsyncRegisterUserRaw(context, cq, tag));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> PrepareAsyncRegisterUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(PrepareAsyncRegisterUserRaw(context, cq));
	+ }
	+ // Called by user to create an active session and get an access token
	+ std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>> LoginUser(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>>(LoginUserRaw(context));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>> AsyncLoginUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>>(AsyncLoginUserRaw(context, cq, tag));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>> PrepareAsyncLoginUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>>(PrepareAsyncLoginUserRaw(context, cq));
	+ }
	+ // Called by other services to verify a user's token
	+ virtual ::grpc::Status VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::identity::VerifyUserTokenResponse* response) = 0;
	+ std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>> AsyncVerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>>(AsyncVerifyUserTokenRaw(context, request, cq));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>> PrepareAsyncVerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>>(PrepareAsyncVerifyUserTokenRaw(context, request, cq));
	+ }
	+ class async_interface {
	+ public:
	+ virtual ~async_interface() {}
	+ // Called by user to register with the Identity Service (PAKE only)
	+ virtual void RegisterUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::RegistrationRequest,::identity::RegistrationResponse>* reactor) = 0;
	+ // Called by user to create an active session and get an access token
	+ virtual void LoginUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::LoginRequest,::identity::LoginResponse>* reactor) = 0;
	+ // Called by other services to verify a user's token
	+ virtual void VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, std::function<void(::grpc::Status)>) = 0;
	+ virtual void VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, ::grpc::ClientUnaryReactor* 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::ClientReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* RegisterUserRaw(::grpc::ClientContext* context) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* AsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* PrepareAsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
	+ virtual ::grpc::ClientReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>* LoginUserRaw(::grpc::ClientContext* context) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>* AsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
	+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>* PrepareAsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
	+ virtual ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>* AsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) = 0;
	+ virtual ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>* PrepareAsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::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::ClientReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> RegisterUser(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(RegisterUserRaw(context));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> AsyncRegisterUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(AsyncRegisterUserRaw(context, cq, tag));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> PrepareAsyncRegisterUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(PrepareAsyncRegisterUserRaw(context, cq));
	+ }
	+ std::unique_ptr< ::grpc::ClientReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>> LoginUser(::grpc::ClientContext* context) {
	+ return std::unique_ptr< ::grpc::ClientReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>>(LoginUserRaw(context));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>> AsyncLoginUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>>(AsyncLoginUserRaw(context, cq, tag));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>> PrepareAsyncLoginUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>>(PrepareAsyncLoginUserRaw(context, cq));
	+ }
	+ ::grpc::Status VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::identity::VerifyUserTokenResponse* response) override;
	+ std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>> AsyncVerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>>(AsyncVerifyUserTokenRaw(context, request, cq));
	+ }
	+ std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>> PrepareAsyncVerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
	+ return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>>(PrepareAsyncVerifyUserTokenRaw(context, request, cq));
	+ }
	+ class async final :
	+ public StubInterface::async_interface {
	+ public:
	+ void RegisterUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::RegistrationRequest,::identity::RegistrationResponse>* reactor) override;
	+ void LoginUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::LoginRequest,::identity::LoginResponse>* reactor) override;
	+ void VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, std::function<void(::grpc::Status)>) override;
	+ void VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
	+ private:
	+ friend class Stub;
	+ explicit async(Stub* stub): stub_(stub) { }
	+ Stub* stub() { return stub_; }
	+ Stub* stub_;
	+ };
	+ class async* async() override { return &async_stub_; }
	+
	+ private:
	+ std::shared_ptr< ::grpc::ChannelInterface> channel_;
	+ class async async_stub_{this};
	+ ::grpc::ClientReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* RegisterUserRaw(::grpc::ClientContext* context) override;
	+ ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* AsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
	+ ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* PrepareAsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
	+ ::grpc::ClientReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* LoginUserRaw(::grpc::ClientContext* context) override;
	+ ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* AsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
	+ ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* PrepareAsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
	+ ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>* AsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) override;
	+ ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>* PrepareAsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) override;
	+ const ::grpc::internal::RpcMethod rpcmethod_RegisterUser_;
	+ const ::grpc::internal::RpcMethod rpcmethod_LoginUser_;
	+ const ::grpc::internal::RpcMethod rpcmethod_VerifyUserToken_;
	+ };
	+ static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
	+
	+ class Service : public ::grpc::Service {
	+ public:
	+ Service();
	+ virtual ~Service();
	+ // Called by user to register with the Identity Service (PAKE only)
	+ virtual ::grpc::Status RegisterUser(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* stream);
	+ // Called by user to create an active session and get an access token
	+ virtual ::grpc::Status LoginUser(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* stream);
	+ // Called by other services to verify a user's token
	+ virtual ::grpc::Status VerifyUserToken(::grpc::ServerContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response);
	+ };
	+ template <class BaseClass>
	+ class WithAsyncMethod_RegisterUser : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithAsyncMethod_RegisterUser() {
	+ ::grpc::Service::MarkMethodAsync(0);
	+ }
	+ ~WithAsyncMethod_RegisterUser() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status RegisterUser(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ void RequestRegisterUser(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* 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>
	+ class WithAsyncMethod_LoginUser : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithAsyncMethod_LoginUser() {
	+ ::grpc::Service::MarkMethodAsync(1);
	+ }
	+ ~WithAsyncMethod_LoginUser() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status LoginUser(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ void RequestLoginUser(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncBidiStreaming(1, context, stream, new_call_cq, notification_cq, tag);
	+ }
	+ };
	+ template <class BaseClass>
	+ class WithAsyncMethod_VerifyUserToken : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithAsyncMethod_VerifyUserToken() {
	+ ::grpc::Service::MarkMethodAsync(2);
	+ }
	+ ~WithAsyncMethod_VerifyUserToken() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status VerifyUserToken(::grpc::ServerContext* /context/, const ::identity::VerifyUserTokenRequest* /request/, ::identity::VerifyUserTokenResponse* /response/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ void RequestVerifyUserToken(::grpc::ServerContext* context, ::identity::VerifyUserTokenRequest* request, ::grpc::ServerAsyncResponseWriter< ::identity::VerifyUserTokenResponse>* 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);
	+ }
	+ };
	+ typedef WithAsyncMethod_RegisterUser<WithAsyncMethod_LoginUser<WithAsyncMethod_VerifyUserToken<Service > > > AsyncService;
	+ template <class BaseClass>
	+ class WithCallbackMethod_RegisterUser : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithCallbackMethod_RegisterUser() {
	+ ::grpc::Service::MarkMethodCallback(0,
	+ new ::grpc::internal::CallbackBidiHandler< ::identity::RegistrationRequest, ::identity::RegistrationResponse>(
	+ [this](
	+ ::grpc::CallbackServerContext* context) { return this->RegisterUser(context); }));
	+ }
	+ ~WithCallbackMethod_RegisterUser() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status RegisterUser(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ virtual ::grpc::ServerBidiReactor< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* RegisterUser(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	+ };
	+ template <class BaseClass>
	+ class WithCallbackMethod_LoginUser : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithCallbackMethod_LoginUser() {
	+ ::grpc::Service::MarkMethodCallback(1,
	+ new ::grpc::internal::CallbackBidiHandler< ::identity::LoginRequest, ::identity::LoginResponse>(
	+ [this](
	+ ::grpc::CallbackServerContext* context) { return this->LoginUser(context); }));
	+ }
	+ ~WithCallbackMethod_LoginUser() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status LoginUser(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ virtual ::grpc::ServerBidiReactor< ::identity::LoginRequest, ::identity::LoginResponse>* LoginUser(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	+ };
	+ template <class BaseClass>
	+ class WithCallbackMethod_VerifyUserToken : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithCallbackMethod_VerifyUserToken() {
	+ ::grpc::Service::MarkMethodCallback(2,
	+ new ::grpc::internal::CallbackUnaryHandler< ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse>(
	+ [this](
	+ ::grpc::CallbackServerContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response) { return this->VerifyUserToken(context, request, response); }));}
	+ void SetMessageAllocatorFor_VerifyUserToken(
	+ ::grpc::MessageAllocator< ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse>* allocator) {
	+ ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
	+ static_cast<::grpc::internal::CallbackUnaryHandler< ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse>*>(handler)
	+ ->SetMessageAllocator(allocator);
	+ }
	+ ~WithCallbackMethod_VerifyUserToken() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status VerifyUserToken(::grpc::ServerContext* /context/, const ::identity::VerifyUserTokenRequest* /request/, ::identity::VerifyUserTokenResponse* /response/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ virtual ::grpc::ServerUnaryReactor* VerifyUserToken(
	+ ::grpc::CallbackServerContext* /context/, const ::identity::VerifyUserTokenRequest* /request/, ::identity::VerifyUserTokenResponse* /response/) { return nullptr; }
	+ };
	+ typedef WithCallbackMethod_RegisterUser<WithCallbackMethod_LoginUser<WithCallbackMethod_VerifyUserToken<Service > > > CallbackService;
	+ typedef CallbackService ExperimentalCallbackService;
	+ template <class BaseClass>
	+ class WithGenericMethod_RegisterUser : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithGenericMethod_RegisterUser() {
	+ ::grpc::Service::MarkMethodGeneric(0);
	+ }
	+ ~WithGenericMethod_RegisterUser() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status RegisterUser(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ };
	+ template <class BaseClass>
	+ class WithGenericMethod_LoginUser : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithGenericMethod_LoginUser() {
	+ ::grpc::Service::MarkMethodGeneric(1);
	+ }
	+ ~WithGenericMethod_LoginUser() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status LoginUser(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ };
	+ template <class BaseClass>
	+ class WithGenericMethod_VerifyUserToken : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithGenericMethod_VerifyUserToken() {
	+ ::grpc::Service::MarkMethodGeneric(2);
	+ }
	+ ~WithGenericMethod_VerifyUserToken() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status VerifyUserToken(::grpc::ServerContext* /context/, const ::identity::VerifyUserTokenRequest* /request/, ::identity::VerifyUserTokenResponse* /response/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ };
	+ template <class BaseClass>
	+ class WithRawMethod_RegisterUser : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithRawMethod_RegisterUser() {
	+ ::grpc::Service::MarkMethodRaw(0);
	+ }
	+ ~WithRawMethod_RegisterUser() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status RegisterUser(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ void RequestRegisterUser(::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>
	+ class WithRawMethod_LoginUser : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithRawMethod_LoginUser() {
	+ ::grpc::Service::MarkMethodRaw(1);
	+ }
	+ ~WithRawMethod_LoginUser() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status LoginUser(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ void RequestLoginUser(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
	+ ::grpc::Service::RequestAsyncBidiStreaming(1, context, stream, new_call_cq, notification_cq, tag);
	+ }
	+ };
	+ template <class BaseClass>
	+ class WithRawMethod_VerifyUserToken : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithRawMethod_VerifyUserToken() {
	+ ::grpc::Service::MarkMethodRaw(2);
	+ }
	+ ~WithRawMethod_VerifyUserToken() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status VerifyUserToken(::grpc::ServerContext* /context/, const ::identity::VerifyUserTokenRequest* /request/, ::identity::VerifyUserTokenResponse* /response/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ void RequestVerifyUserToken(::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);
	+ }
	+ };
	+ template <class BaseClass>
	+ class WithRawCallbackMethod_RegisterUser : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithRawCallbackMethod_RegisterUser() {
	+ ::grpc::Service::MarkMethodRawCallback(0,
	+ new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	+ [this](
	+ ::grpc::CallbackServerContext* context) { return this->RegisterUser(context); }));
	+ }
	+ ~WithRawCallbackMethod_RegisterUser() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status RegisterUser(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* RegisterUser(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	+ };
	+ template <class BaseClass>
	+ class WithRawCallbackMethod_LoginUser : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithRawCallbackMethod_LoginUser() {
	+ ::grpc::Service::MarkMethodRawCallback(1,
	+ new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	+ [this](
	+ ::grpc::CallbackServerContext* context) { return this->LoginUser(context); }));
	+ }
	+ ~WithRawCallbackMethod_LoginUser() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status LoginUser(::grpc::ServerContext* /context/, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* /stream/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* LoginUser(
	+ ::grpc::CallbackServerContext* /context/)
	+ { return nullptr; }
	+ };
	+ template <class BaseClass>
	+ class WithRawCallbackMethod_VerifyUserToken : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithRawCallbackMethod_VerifyUserToken() {
	+ ::grpc::Service::MarkMethodRawCallback(2,
	+ new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
	+ [this](
	+ ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->VerifyUserToken(context, request, response); }));
	+ }
	+ ~WithRawCallbackMethod_VerifyUserToken() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable synchronous version of this method
	+ ::grpc::Status VerifyUserToken(::grpc::ServerContext* /context/, const ::identity::VerifyUserTokenRequest* /request/, ::identity::VerifyUserTokenResponse* /response/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ virtual ::grpc::ServerUnaryReactor* VerifyUserToken(
	+ ::grpc::CallbackServerContext* /context/, const ::grpc::ByteBuffer* /request/, ::grpc::ByteBuffer* /response/) { return nullptr; }
	+ };
	+ template <class BaseClass>
	+ class WithStreamedUnaryMethod_VerifyUserToken : public BaseClass {
	+ private:
	+ void BaseClassMustBeDerivedFromService(const Service* /service/) {}
	+ public:
	+ WithStreamedUnaryMethod_VerifyUserToken() {
	+ ::grpc::Service::MarkMethodStreamed(2,
	+ new ::grpc::internal::StreamedUnaryHandler<
	+ ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse>(
	+ [this](::grpc::ServerContext* context,
	+ ::grpc::ServerUnaryStreamer<
	+ ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse>* streamer) {
	+ return this->StreamedVerifyUserToken(context,
	+ streamer);
	+ }));
	+ }
	+ ~WithStreamedUnaryMethod_VerifyUserToken() override {
	+ BaseClassMustBeDerivedFromService(this);
	+ }
	+ // disable regular version of this method
	+ ::grpc::Status VerifyUserToken(::grpc::ServerContext* /context/, const ::identity::VerifyUserTokenRequest* /request/, ::identity::VerifyUserTokenResponse* /response/) override {
	+ abort();
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+ }
	+ // replace default version of method with streamed unary
	+ virtual ::grpc::Status StreamedVerifyUserToken(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::identity::VerifyUserTokenRequest,::identity::VerifyUserTokenResponse>* server_unary_streamer) = 0;
	+ };
	+ typedef WithStreamedUnaryMethod_VerifyUserToken<Service > StreamedUnaryService;
	+ typedef Service SplitStreamedService;
	+ typedef WithStreamedUnaryMethod_VerifyUserToken<Service > StreamedService;
	+};
	+
	+} // namespace identity
	+
	+
	+#endif // GRPC_identity_2eproto__INCLUDED
	diff --git a/native/cpp/CommonCpp/grpc/_generated/identity.grpc.pb.cc b/native/cpp/CommonCpp/grpc/_generated/identity.grpc.pb.cc
	new file mode 100644
	--- /dev/null
	+++ b/native/cpp/CommonCpp/grpc/_generated/identity.grpc.pb.cc
	@@ -0,0 +1,154 @@
	+// @generated by the gRPC C++ plugin.
	+// If you make any local change, they will be lost.
	+// source: identity.proto
	+
	+#include "identity.pb.h"
	+#include "identity.grpc.pb.h"
	+
	+#include <functional>
	+#include <grpcpp/impl/codegen/async_stream.h>
	+#include <grpcpp/impl/codegen/async_unary_call.h>
	+#include <grpcpp/impl/codegen/channel_interface.h>
	+#include <grpcpp/impl/codegen/client_unary_call.h>
	+#include <grpcpp/impl/codegen/client_callback.h>
	+#include <grpcpp/impl/codegen/message_allocator.h>
	+#include <grpcpp/impl/codegen/method_handler.h>
	+#include <grpcpp/impl/codegen/rpc_service_method.h>
	+#include <grpcpp/impl/codegen/server_callback.h>
	+#include <grpcpp/impl/codegen/server_callback_handlers.h>
	+#include <grpcpp/impl/codegen/server_context.h>
	+#include <grpcpp/impl/codegen/service_type.h>
	+#include <grpcpp/impl/codegen/sync_stream.h>
	+namespace identity {
	+
	+static const char* IdentityService_method_names[] = {
	+ "/identity.IdentityService/RegisterUser",
	+ "/identity.IdentityService/LoginUser",
	+ "/identity.IdentityService/VerifyUserToken",
	+};
	+
	+std::unique_ptr< IdentityService::Stub> IdentityService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
	+ (void)options;
	+ std::unique_ptr< IdentityService::Stub> stub(new IdentityService::Stub(channel, options));
	+ return stub;
	+}
	+
	+IdentityService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
	+ : channel_(channel), rpcmethod_RegisterUser_(IdentityService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
	+ , rpcmethod_LoginUser_(IdentityService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
	+ , rpcmethod_VerifyUserToken_(IdentityService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
	+ {}
	+
	+::grpc::ClientReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* IdentityService::Stub::RegisterUserRaw(::grpc::ClientContext* context) {
	+ return ::grpc::internal::ClientReaderWriterFactory< ::identity::RegistrationRequest, ::identity::RegistrationResponse>::Create(channel_.get(), rpcmethod_RegisterUser_, context);
	+}
	+
	+void IdentityService::Stub::async::RegisterUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::RegistrationRequest,::identity::RegistrationResponse>* reactor) {
	+ ::grpc::internal::ClientCallbackReaderWriterFactory< ::identity::RegistrationRequest,::identity::RegistrationResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_RegisterUser_, context, reactor);
	+}
	+
	+::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* IdentityService::Stub::AsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::identity::RegistrationRequest, ::identity::RegistrationResponse>::Create(channel_.get(), cq, rpcmethod_RegisterUser_, context, true, tag);
	+}
	+
	+::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* IdentityService::Stub::PrepareAsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::identity::RegistrationRequest, ::identity::RegistrationResponse>::Create(channel_.get(), cq, rpcmethod_RegisterUser_, context, false, nullptr);
	+}
	+
	+::grpc::ClientReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* IdentityService::Stub::LoginUserRaw(::grpc::ClientContext* context) {
	+ return ::grpc::internal::ClientReaderWriterFactory< ::identity::LoginRequest, ::identity::LoginResponse>::Create(channel_.get(), rpcmethod_LoginUser_, context);
	+}
	+
	+void IdentityService::Stub::async::LoginUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::LoginRequest,::identity::LoginResponse>* reactor) {
	+ ::grpc::internal::ClientCallbackReaderWriterFactory< ::identity::LoginRequest,::identity::LoginResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_LoginUser_, context, reactor);
	+}
	+
	+::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* IdentityService::Stub::AsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::identity::LoginRequest, ::identity::LoginResponse>::Create(channel_.get(), cq, rpcmethod_LoginUser_, context, true, tag);
	+}
	+
	+::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* IdentityService::Stub::PrepareAsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
	+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::identity::LoginRequest, ::identity::LoginResponse>::Create(channel_.get(), cq, rpcmethod_LoginUser_, context, false, nullptr);
	+}
	+
	+::grpc::Status IdentityService::Stub::VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::identity::VerifyUserTokenResponse* response) {
	+ return ::grpc::internal::BlockingUnaryCall< ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_VerifyUserToken_, context, request, response);
	+}
	+
	+void IdentityService::Stub::async::VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, std::function<void(::grpc::Status)> f) {
	+ ::grpc::internal::CallbackUnaryCall< ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_VerifyUserToken_, context, request, response, std::move(f));
	+}
	+
	+void IdentityService::Stub::async::VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, ::grpc::ClientUnaryReactor* reactor) {
	+ ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_VerifyUserToken_, context, request, response, reactor);
	+}
	+
	+::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>* IdentityService::Stub::PrepareAsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
	+ return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::identity::VerifyUserTokenResponse, ::identity::VerifyUserTokenRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_VerifyUserToken_, context, request);
	+}
	+
	+::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>* IdentityService::Stub::AsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
	+ auto* result =
	+ this->PrepareAsyncVerifyUserTokenRaw(context, request, cq);
	+ result->StartCall();
	+ return result;
	+}
	+
	+IdentityService::Service::Service() {
	+ AddMethod(new ::grpc::internal::RpcServiceMethod(
	+ IdentityService_method_names[0],
	+ ::grpc::internal::RpcMethod::BIDI_STREAMING,
	+ new ::grpc::internal::BidiStreamingHandler< IdentityService::Service, ::identity::RegistrationRequest, ::identity::RegistrationResponse>(
	+ [](IdentityService::Service* service,
	+ ::grpc::ServerContext* ctx,
	+ ::grpc::ServerReaderWriter<::identity::RegistrationResponse,
	+ ::identity::RegistrationRequest>* stream) {
	+ return service->RegisterUser(ctx, stream);
	+ }, this)));
	+ AddMethod(new ::grpc::internal::RpcServiceMethod(
	+ IdentityService_method_names[1],
	+ ::grpc::internal::RpcMethod::BIDI_STREAMING,
	+ new ::grpc::internal::BidiStreamingHandler< IdentityService::Service, ::identity::LoginRequest, ::identity::LoginResponse>(
	+ [](IdentityService::Service* service,
	+ ::grpc::ServerContext* ctx,
	+ ::grpc::ServerReaderWriter<::identity::LoginResponse,
	+ ::identity::LoginRequest>* stream) {
	+ return service->LoginUser(ctx, stream);
	+ }, this)));
	+ AddMethod(new ::grpc::internal::RpcServiceMethod(
	+ IdentityService_method_names[2],
	+ ::grpc::internal::RpcMethod::NORMAL_RPC,
	+ new ::grpc::internal::RpcMethodHandler< IdentityService::Service, ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
	+ [](IdentityService::Service* service,
	+ ::grpc::ServerContext* ctx,
	+ const ::identity::VerifyUserTokenRequest* req,
	+ ::identity::VerifyUserTokenResponse* resp) {
	+ return service->VerifyUserToken(ctx, req, resp);
	+ }, this)));
	+}
	+
	+IdentityService::Service::~Service() {
	+}
	+
	+::grpc::Status IdentityService::Service::RegisterUser(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* stream) {
	+ (void) context;
	+ (void) stream;
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+}
	+
	+::grpc::Status IdentityService::Service::LoginUser(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* stream) {
	+ (void) context;
	+ (void) stream;
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+}
	+
	+::grpc::Status IdentityService::Service::VerifyUserToken(::grpc::ServerContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response) {
	+ (void) context;
	+ (void) request;
	+ (void) response;
	+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
	+}
	+
	+
	+} // namespace identity
	+
	diff --git a/native/cpp/CommonCpp/grpc/_generated/identity.pb.h b/native/cpp/CommonCpp/grpc/_generated/identity.pb.h
	new file mode 100644
	--- /dev/null
	+++ b/native/cpp/CommonCpp/grpc/_generated/identity.pb.h
	@@ -0,0 +1,4716 @@
	+// @generated by the protocol buffer compiler. DO NOT EDIT!
	+// source: identity.proto
	+
	+#ifndef GOOGLE_PROTOBUF_INCLUDED_identity_2eproto
	+#define GOOGLE_PROTOBUF_INCLUDED_identity_2eproto
	+
	+#include <limits>
	+#include <string>
	+
	+#include <google/protobuf/port_def.inc>
	+#if PROTOBUF_VERSION < 3015000
	+#error This file was generated by a newer version of protoc which is
	+#error incompatible with your Protocol Buffer headers. Please update
	+#error your headers.
	+#endif
	+#if 3015008 < PROTOBUF_MIN_PROTOC_VERSION
	+#error This file was generated by an older version of protoc which is
	+#error incompatible with your Protocol Buffer headers. Please
	+#error regenerate this file with a newer version of protoc.
	+#endif
	+
	+#include <google/protobuf/port_undef.inc>
	+#include <google/protobuf/io/coded_stream.h>
	+#include <google/protobuf/arena.h>
	+#include <google/protobuf/arenastring.h>
	+#include <google/protobuf/generated_message_table_driven.h>
	+#include <google/protobuf/generated_message_util.h>
	+#include <google/protobuf/metadata_lite.h>
	+#include <google/protobuf/generated_message_reflection.h>
	+#include <google/protobuf/message.h>
	+#include <google/protobuf/repeated_field.h> // IWYU pragma: export
	+#include <google/protobuf/extension_set.h> // IWYU pragma: export
	+#include <google/protobuf/unknown_field_set.h>
	+// @@protoc_insertion_point(includes)
	+#include <google/protobuf/port_def.inc>
	+#define PROTOBUF_INTERNAL_EXPORT_identity_2eproto
	+PROTOBUF_NAMESPACE_OPEN
	+namespace internal {
	+class AnyMetadata;
	+} // namespace internal
	+PROTOBUF_NAMESPACE_CLOSE
	+
	+// Internal implementation detail -- do not use these members.
	+struct TableStruct_identity_2eproto {
	+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
	+ PROTOBUF_SECTION_VARIABLE(protodesc_cold);
	+ static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
	+ PROTOBUF_SECTION_VARIABLE(protodesc_cold);
	+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[13]
	+ PROTOBUF_SECTION_VARIABLE(protodesc_cold);
	+ static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
	+ static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
	+ static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
	+};
	+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_identity_2eproto;
	+::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_identity_2eproto_metadata_getter(int index);
	+namespace identity {
	+class LoginRequest;
	+struct LoginRequestDefaultTypeInternal;
	+extern LoginRequestDefaultTypeInternal _LoginRequest_default_instance_;
	+class LoginResponse;
	+struct LoginResponseDefaultTypeInternal;
	+extern LoginResponseDefaultTypeInternal _LoginResponse_default_instance_;
	+class PakeCredentialRequestAndUserID;
	+struct PakeCredentialRequestAndUserIDDefaultTypeInternal;
	+extern PakeCredentialRequestAndUserIDDefaultTypeInternal _PakeCredentialRequestAndUserID_default_instance_;
	+class PakeLoginRequest;
	+struct PakeLoginRequestDefaultTypeInternal;
	+extern PakeLoginRequestDefaultTypeInternal _PakeLoginRequest_default_instance_;
	+class PakeLoginResponse;
	+struct PakeLoginResponseDefaultTypeInternal;
	+extern PakeLoginResponseDefaultTypeInternal _PakeLoginResponse_default_instance_;
	+class PakeRegistrationRequestAndUserID;
	+struct PakeRegistrationRequestAndUserIDDefaultTypeInternal;
	+extern PakeRegistrationRequestAndUserIDDefaultTypeInternal _PakeRegistrationRequestAndUserID_default_instance_;
	+class PakeRegistrationUploadAndCredentialRequest;
	+struct PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal;
	+extern PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal _PakeRegistrationUploadAndCredentialRequest_default_instance_;
	+class RegistrationRequest;
	+struct RegistrationRequestDefaultTypeInternal;
	+extern RegistrationRequestDefaultTypeInternal _RegistrationRequest_default_instance_;
	+class RegistrationResponse;
	+struct RegistrationResponseDefaultTypeInternal;
	+extern RegistrationResponseDefaultTypeInternal _RegistrationResponse_default_instance_;
	+class VerifyUserTokenRequest;
	+struct VerifyUserTokenRequestDefaultTypeInternal;
	+extern VerifyUserTokenRequestDefaultTypeInternal _VerifyUserTokenRequest_default_instance_;
	+class VerifyUserTokenResponse;
	+struct VerifyUserTokenResponseDefaultTypeInternal;
	+extern VerifyUserTokenResponseDefaultTypeInternal _VerifyUserTokenResponse_default_instance_;
	+class WalletLoginRequest;
	+struct WalletLoginRequestDefaultTypeInternal;
	+extern WalletLoginRequestDefaultTypeInternal _WalletLoginRequest_default_instance_;
	+class WalletLoginResponse;
	+struct WalletLoginResponseDefaultTypeInternal;
	+extern WalletLoginResponseDefaultTypeInternal _WalletLoginResponse_default_instance_;
	+} // namespace identity
	+PROTOBUF_NAMESPACE_OPEN
	+template<> ::identity::LoginRequest* Arena::CreateMaybeMessage<::identity::LoginRequest>(Arena*);
	+template<> ::identity::LoginResponse* Arena::CreateMaybeMessage<::identity::LoginResponse>(Arena*);
	+template<> ::identity::PakeCredentialRequestAndUserID* Arena::CreateMaybeMessage<::identity::PakeCredentialRequestAndUserID>(Arena*);
	+template<> ::identity::PakeLoginRequest* Arena::CreateMaybeMessage<::identity::PakeLoginRequest>(Arena*);
	+template<> ::identity::PakeLoginResponse* Arena::CreateMaybeMessage<::identity::PakeLoginResponse>(Arena*);
	+template<> ::identity::PakeRegistrationRequestAndUserID* Arena::CreateMaybeMessage<::identity::PakeRegistrationRequestAndUserID>(Arena*);
	+template<> ::identity::PakeRegistrationUploadAndCredentialRequest* Arena::CreateMaybeMessage<::identity::PakeRegistrationUploadAndCredentialRequest>(Arena*);
	+template<> ::identity::RegistrationRequest* Arena::CreateMaybeMessage<::identity::RegistrationRequest>(Arena*);
	+template<> ::identity::RegistrationResponse* Arena::CreateMaybeMessage<::identity::RegistrationResponse>(Arena*);
	+template<> ::identity::VerifyUserTokenRequest* Arena::CreateMaybeMessage<::identity::VerifyUserTokenRequest>(Arena*);
	+template<> ::identity::VerifyUserTokenResponse* Arena::CreateMaybeMessage<::identity::VerifyUserTokenResponse>(Arena*);
	+template<> ::identity::WalletLoginRequest* Arena::CreateMaybeMessage<::identity::WalletLoginRequest>(Arena*);
	+template<> ::identity::WalletLoginResponse* Arena::CreateMaybeMessage<::identity::WalletLoginResponse>(Arena*);
	+PROTOBUF_NAMESPACE_CLOSE
	+namespace identity {
	+
	+// ===================================================================
	+
	+class PakeRegistrationRequestAndUserID PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.PakeRegistrationRequestAndUserID) */ {
	+ public:
	+ inline PakeRegistrationRequestAndUserID() : PakeRegistrationRequestAndUserID(nullptr) {}
	+ virtual ~PakeRegistrationRequestAndUserID();
	+ explicit constexpr PakeRegistrationRequestAndUserID(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ PakeRegistrationRequestAndUserID(const PakeRegistrationRequestAndUserID& from);
	+ PakeRegistrationRequestAndUserID(PakeRegistrationRequestAndUserID&& from) noexcept
	+ : PakeRegistrationRequestAndUserID() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline PakeRegistrationRequestAndUserID& operator=(const PakeRegistrationRequestAndUserID& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline PakeRegistrationRequestAndUserID& operator=(PakeRegistrationRequestAndUserID&& 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 PakeRegistrationRequestAndUserID& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const PakeRegistrationRequestAndUserID* internal_default_instance() {
	+ return reinterpret_cast<const PakeRegistrationRequestAndUserID*>(
	+ &_PakeRegistrationRequestAndUserID_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 0;
	+
	+ friend void swap(PakeRegistrationRequestAndUserID& a, PakeRegistrationRequestAndUserID& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(PakeRegistrationRequestAndUserID* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(PakeRegistrationRequestAndUserID* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline PakeRegistrationRequestAndUserID* New() const final {
	+ return CreateMaybeMessage<PakeRegistrationRequestAndUserID>(nullptr);
	+ }
	+
	+ PakeRegistrationRequestAndUserID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<PakeRegistrationRequestAndUserID>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const PakeRegistrationRequestAndUserID& from);
	+ void MergeFrom(const PakeRegistrationRequestAndUserID& 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(PakeRegistrationRequestAndUserID* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.PakeRegistrationRequestAndUserID";
	+ }
	+ protected:
	+ explicit PakeRegistrationRequestAndUserID(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kUserIDFieldNumber = 1,
	+ kDeviceIDFieldNumber = 2,
	+ kPakeRegistrationRequestFieldNumber = 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);
	+ private:
	+ const std::string& _internal_userid() const;
	+ void _internal_set_userid(const std::string& value);
	+ std::string* _internal_mutable_userid();
	+ public:
	+
	+ // string deviceID = 2;
	+ void clear_deviceid();
	+ const std::string& deviceid() const;
	+ void set_deviceid(const std::string& value);
	+ void set_deviceid(std::string&& value);
	+ void set_deviceid(const char* value);
	+ void set_deviceid(const char* value, size_t size);
	+ std::string* mutable_deviceid();
	+ std::string* release_deviceid();
	+ void set_allocated_deviceid(std::string* deviceid);
	+ private:
	+ const std::string& _internal_deviceid() const;
	+ void _internal_set_deviceid(const std::string& value);
	+ std::string* _internal_mutable_deviceid();
	+ public:
	+
	+ // bytes pakeRegistrationRequest = 3;
	+ 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_pakeregistrationrequest() const;
	+ void _internal_set_pakeregistrationrequest(const std::string& value);
	+ std::string* _internal_mutable_pakeregistrationrequest();
	+ public:
	+
	+ // @@protoc_insertion_point(class_scope:identity.PakeRegistrationRequestAndUserID)
	+ 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 deviceid_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationrequest_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class PakeCredentialRequestAndUserID PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.PakeCredentialRequestAndUserID) */ {
	+ public:
	+ inline PakeCredentialRequestAndUserID() : PakeCredentialRequestAndUserID(nullptr) {}
	+ virtual ~PakeCredentialRequestAndUserID();
	+ explicit constexpr PakeCredentialRequestAndUserID(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ PakeCredentialRequestAndUserID(const PakeCredentialRequestAndUserID& from);
	+ PakeCredentialRequestAndUserID(PakeCredentialRequestAndUserID&& from) noexcept
	+ : PakeCredentialRequestAndUserID() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline PakeCredentialRequestAndUserID& operator=(const PakeCredentialRequestAndUserID& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline PakeCredentialRequestAndUserID& operator=(PakeCredentialRequestAndUserID&& 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 PakeCredentialRequestAndUserID& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const PakeCredentialRequestAndUserID* internal_default_instance() {
	+ return reinterpret_cast<const PakeCredentialRequestAndUserID*>(
	+ &_PakeCredentialRequestAndUserID_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 1;
	+
	+ friend void swap(PakeCredentialRequestAndUserID& a, PakeCredentialRequestAndUserID& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(PakeCredentialRequestAndUserID* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(PakeCredentialRequestAndUserID* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline PakeCredentialRequestAndUserID* New() const final {
	+ return CreateMaybeMessage<PakeCredentialRequestAndUserID>(nullptr);
	+ }
	+
	+ PakeCredentialRequestAndUserID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<PakeCredentialRequestAndUserID>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const PakeCredentialRequestAndUserID& from);
	+ void MergeFrom(const PakeCredentialRequestAndUserID& 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(PakeCredentialRequestAndUserID* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.PakeCredentialRequestAndUserID";
	+ }
	+ protected:
	+ explicit PakeCredentialRequestAndUserID(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kUserIDFieldNumber = 1,
	+ kDeviceIDFieldNumber = 2,
	+ kPakeCredentialRequestFieldNumber = 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);
	+ private:
	+ const std::string& _internal_userid() const;
	+ void _internal_set_userid(const std::string& value);
	+ std::string* _internal_mutable_userid();
	+ public:
	+
	+ // string deviceID = 2;
	+ void clear_deviceid();
	+ const std::string& deviceid() const;
	+ void set_deviceid(const std::string& value);
	+ void set_deviceid(std::string&& value);
	+ void set_deviceid(const char* value);
	+ void set_deviceid(const char* value, size_t size);
	+ std::string* mutable_deviceid();
	+ std::string* release_deviceid();
	+ void set_allocated_deviceid(std::string* deviceid);
	+ private:
	+ const std::string& _internal_deviceid() const;
	+ void _internal_set_deviceid(const std::string& value);
	+ std::string* _internal_mutable_deviceid();
	+ public:
	+
	+ // bytes pakeCredentialRequest = 3;
	+ 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:
	+
	+ // @@protoc_insertion_point(class_scope:identity.PakeCredentialRequestAndUserID)
	+ 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 deviceid_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialrequest_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class PakeLoginRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.PakeLoginRequest) */ {
	+ public:
	+ inline PakeLoginRequest() : PakeLoginRequest(nullptr) {}
	+ virtual ~PakeLoginRequest();
	+ explicit constexpr PakeLoginRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ PakeLoginRequest(const PakeLoginRequest& from);
	+ PakeLoginRequest(PakeLoginRequest&& from) noexcept
	+ : PakeLoginRequest() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline PakeLoginRequest& operator=(const PakeLoginRequest& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline PakeLoginRequest& operator=(PakeLoginRequest&& 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 PakeLoginRequest& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ enum DataCase {
	+ kPakeCredentialRequestAndUserID = 1,
	+ kPakeCredentialFinalization = 2,
	+ DATA_NOT_SET = 0,
	+ };
	+
	+ static inline const PakeLoginRequest* internal_default_instance() {
	+ return reinterpret_cast<const PakeLoginRequest*>(
	+ &_PakeLoginRequest_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 2;
	+
	+ friend void swap(PakeLoginRequest& a, PakeLoginRequest& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(PakeLoginRequest* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(PakeLoginRequest* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline PakeLoginRequest* New() const final {
	+ return CreateMaybeMessage<PakeLoginRequest>(nullptr);
	+ }
	+
	+ PakeLoginRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<PakeLoginRequest>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const PakeLoginRequest& from);
	+ void MergeFrom(const PakeLoginRequest& 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(PakeLoginRequest* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.PakeLoginRequest";
	+ }
	+ protected:
	+ explicit PakeLoginRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kPakeCredentialRequestAndUserIDFieldNumber = 1,
	+ kPakeCredentialFinalizationFieldNumber = 2,
	+ };
	+ // .identity.PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
	+ bool has_pakecredentialrequestanduserid() const;
	+ private:
	+ bool _internal_has_pakecredentialrequestanduserid() const;
	+ public:
	+ void clear_pakecredentialrequestanduserid();
	+ const ::identity::PakeCredentialRequestAndUserID& pakecredentialrequestanduserid() const;
	+ ::identity::PakeCredentialRequestAndUserID* release_pakecredentialrequestanduserid();
	+ ::identity::PakeCredentialRequestAndUserID* mutable_pakecredentialrequestanduserid();
	+ void set_allocated_pakecredentialrequestanduserid(::identity::PakeCredentialRequestAndUserID* pakecredentialrequestanduserid);
	+ private:
	+ const ::identity::PakeCredentialRequestAndUserID& _internal_pakecredentialrequestanduserid() const;
	+ ::identity::PakeCredentialRequestAndUserID* _internal_mutable_pakecredentialrequestanduserid();
	+ public:
	+ void unsafe_arena_set_allocated_pakecredentialrequestanduserid(
	+ ::identity::PakeCredentialRequestAndUserID* pakecredentialrequestanduserid);
	+ ::identity::PakeCredentialRequestAndUserID* unsafe_arena_release_pakecredentialrequestanduserid();
	+
	+ // bytes pakeCredentialFinalization = 2;
	+ 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:
	+
	+ void clear_data();
	+ DataCase data_case() const;
	+ // @@protoc_insertion_point(class_scope:identity.PakeLoginRequest)
	+ private:
	+ class _Internal;
	+ void set_has_pakecredentialrequestanduserid();
	+ void set_has_pakecredentialfinalization();
	+
	+ 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_;
	+ ::identity::PakeCredentialRequestAndUserID* pakecredentialrequestanduserid_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialfinalization_;
	+ } data_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class PakeLoginResponse PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.PakeLoginResponse) */ {
	+ public:
	+ inline PakeLoginResponse() : PakeLoginResponse(nullptr) {}
	+ virtual ~PakeLoginResponse();
	+ explicit constexpr PakeLoginResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ PakeLoginResponse(const PakeLoginResponse& from);
	+ PakeLoginResponse(PakeLoginResponse&& from) noexcept
	+ : PakeLoginResponse() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline PakeLoginResponse& operator=(const PakeLoginResponse& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline PakeLoginResponse& operator=(PakeLoginResponse&& 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 PakeLoginResponse& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ enum DataCase {
	+ kPakeCredentialResponse = 1,
	+ kAccessToken = 2,
	+ DATA_NOT_SET = 0,
	+ };
	+
	+ static inline const PakeLoginResponse* internal_default_instance() {
	+ return reinterpret_cast<const PakeLoginResponse*>(
	+ &_PakeLoginResponse_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 3;
	+
	+ friend void swap(PakeLoginResponse& a, PakeLoginResponse& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(PakeLoginResponse* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(PakeLoginResponse* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline PakeLoginResponse* New() const final {
	+ return CreateMaybeMessage<PakeLoginResponse>(nullptr);
	+ }
	+
	+ PakeLoginResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<PakeLoginResponse>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const PakeLoginResponse& from);
	+ void MergeFrom(const PakeLoginResponse& 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(PakeLoginResponse* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.PakeLoginResponse";
	+ }
	+ protected:
	+ explicit PakeLoginResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kPakeCredentialResponseFieldNumber = 1,
	+ kAccessTokenFieldNumber = 2,
	+ };
	+ // bytes pakeCredentialResponse = 1;
	+ 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:
	+
	+ // string accessToken = 2;
	+ bool has_accesstoken() const;
	+ private:
	+ bool _internal_has_accesstoken() const;
	+ public:
	+ void clear_accesstoken();
	+ const std::string& accesstoken() const;
	+ void set_accesstoken(const std::string& value);
	+ void set_accesstoken(std::string&& value);
	+ void set_accesstoken(const char* value);
	+ void set_accesstoken(const char* value, size_t size);
	+ std::string* mutable_accesstoken();
	+ std::string* release_accesstoken();
	+ void set_allocated_accesstoken(std::string* accesstoken);
	+ private:
	+ const std::string& _internal_accesstoken() const;
	+ void _internal_set_accesstoken(const std::string& value);
	+ std::string* _internal_mutable_accesstoken();
	+ public:
	+
	+ void clear_data();
	+ DataCase data_case() const;
	+ // @@protoc_insertion_point(class_scope:identity.PakeLoginResponse)
	+ private:
	+ class _Internal;
	+ void set_has_pakecredentialresponse();
	+ void set_has_accesstoken();
	+
	+ 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 pakecredentialresponse_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accesstoken_;
	+ } data_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class PakeRegistrationUploadAndCredentialRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.PakeRegistrationUploadAndCredentialRequest) */ {
	+ public:
	+ inline PakeRegistrationUploadAndCredentialRequest() : PakeRegistrationUploadAndCredentialRequest(nullptr) {}
	+ virtual ~PakeRegistrationUploadAndCredentialRequest();
	+ explicit constexpr PakeRegistrationUploadAndCredentialRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ PakeRegistrationUploadAndCredentialRequest(const PakeRegistrationUploadAndCredentialRequest& from);
	+ PakeRegistrationUploadAndCredentialRequest(PakeRegistrationUploadAndCredentialRequest&& from) noexcept
	+ : PakeRegistrationUploadAndCredentialRequest() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline PakeRegistrationUploadAndCredentialRequest& operator=(const PakeRegistrationUploadAndCredentialRequest& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline PakeRegistrationUploadAndCredentialRequest& operator=(PakeRegistrationUploadAndCredentialRequest&& 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 PakeRegistrationUploadAndCredentialRequest& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const PakeRegistrationUploadAndCredentialRequest* internal_default_instance() {
	+ return reinterpret_cast<const PakeRegistrationUploadAndCredentialRequest*>(
	+ &_PakeRegistrationUploadAndCredentialRequest_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 4;
	+
	+ friend void swap(PakeRegistrationUploadAndCredentialRequest& a, PakeRegistrationUploadAndCredentialRequest& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(PakeRegistrationUploadAndCredentialRequest* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(PakeRegistrationUploadAndCredentialRequest* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline PakeRegistrationUploadAndCredentialRequest* New() const final {
	+ return CreateMaybeMessage<PakeRegistrationUploadAndCredentialRequest>(nullptr);
	+ }
	+
	+ PakeRegistrationUploadAndCredentialRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<PakeRegistrationUploadAndCredentialRequest>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const PakeRegistrationUploadAndCredentialRequest& from);
	+ void MergeFrom(const PakeRegistrationUploadAndCredentialRequest& 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(PakeRegistrationUploadAndCredentialRequest* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.PakeRegistrationUploadAndCredentialRequest";
	+ }
	+ protected:
	+ explicit PakeRegistrationUploadAndCredentialRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kPakeRegistrationUploadFieldNumber = 1,
	+ kPakeCredentialRequestFieldNumber = 2,
	+ };
	+ // bytes pakeRegistrationUpload = 1;
	+ 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_pakeregistrationupload() const;
	+ void _internal_set_pakeregistrationupload(const std::string& value);
	+ std::string* _internal_mutable_pakeregistrationupload();
	+ public:
	+
	+ // bytes pakeCredentialRequest = 2;
	+ 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:
	+
	+ // @@protoc_insertion_point(class_scope:identity.PakeRegistrationUploadAndCredentialRequest)
	+ private:
	+ class _Internal;
	+
	+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	+ typedef void InternalArenaConstructable_;
	+ typedef void DestructorSkippable_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationupload_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialrequest_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class WalletLoginRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.WalletLoginRequest) */ {
	+ public:
	+ inline WalletLoginRequest() : WalletLoginRequest(nullptr) {}
	+ virtual ~WalletLoginRequest();
	+ explicit constexpr WalletLoginRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ WalletLoginRequest(const WalletLoginRequest& from);
	+ WalletLoginRequest(WalletLoginRequest&& from) noexcept
	+ : WalletLoginRequest() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline WalletLoginRequest& operator=(const WalletLoginRequest& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline WalletLoginRequest& operator=(WalletLoginRequest&& 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 WalletLoginRequest& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const WalletLoginRequest* internal_default_instance() {
	+ return reinterpret_cast<const WalletLoginRequest*>(
	+ &_WalletLoginRequest_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 5;
	+
	+ friend void swap(WalletLoginRequest& a, WalletLoginRequest& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(WalletLoginRequest* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(WalletLoginRequest* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline WalletLoginRequest* New() const final {
	+ return CreateMaybeMessage<WalletLoginRequest>(nullptr);
	+ }
	+
	+ WalletLoginRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<WalletLoginRequest>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const WalletLoginRequest& from);
	+ void MergeFrom(const WalletLoginRequest& 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(WalletLoginRequest* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.WalletLoginRequest";
	+ }
	+ protected:
	+ explicit WalletLoginRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kUserIDFieldNumber = 1,
	+ kDeviceIDFieldNumber = 2,
	+ kSiweMessageFieldNumber = 3,
	+ kSiweSignatureFieldNumber = 4,
	+ };
	+ // 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 deviceID = 2;
	+ void clear_deviceid();
	+ const std::string& deviceid() const;
	+ void set_deviceid(const std::string& value);
	+ void set_deviceid(std::string&& value);
	+ void set_deviceid(const char* value);
	+ void set_deviceid(const char* value, size_t size);
	+ std::string* mutable_deviceid();
	+ std::string* release_deviceid();
	+ void set_allocated_deviceid(std::string* deviceid);
	+ private:
	+ const std::string& _internal_deviceid() const;
	+ void _internal_set_deviceid(const std::string& value);
	+ std::string* _internal_mutable_deviceid();
	+ public:
	+
	+ // string siweMessage = 3;
	+ void clear_siwemessage();
	+ const std::string& siwemessage() const;
	+ void set_siwemessage(const std::string& value);
	+ void set_siwemessage(std::string&& value);
	+ void set_siwemessage(const char* value);
	+ void set_siwemessage(const char* value, size_t size);
	+ std::string* mutable_siwemessage();
	+ std::string* release_siwemessage();
	+ void set_allocated_siwemessage(std::string* siwemessage);
	+ private:
	+ const std::string& _internal_siwemessage() const;
	+ void _internal_set_siwemessage(const std::string& value);
	+ std::string* _internal_mutable_siwemessage();
	+ public:
	+
	+ // bytes siweSignature = 4;
	+ void clear_siwesignature();
	+ const std::string& siwesignature() const;
	+ void set_siwesignature(const std::string& value);
	+ void set_siwesignature(std::string&& value);
	+ void set_siwesignature(const char* value);
	+ void set_siwesignature(const void* value, size_t size);
	+ std::string* mutable_siwesignature();
	+ std::string* release_siwesignature();
	+ void set_allocated_siwesignature(std::string* siwesignature);
	+ private:
	+ const std::string& _internal_siwesignature() const;
	+ void _internal_set_siwesignature(const std::string& value);
	+ std::string* _internal_mutable_siwesignature();
	+ public:
	+
	+ // @@protoc_insertion_point(class_scope:identity.WalletLoginRequest)
	+ 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 deviceid_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr siwemessage_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr siwesignature_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class WalletLoginResponse PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.WalletLoginResponse) */ {
	+ public:
	+ inline WalletLoginResponse() : WalletLoginResponse(nullptr) {}
	+ virtual ~WalletLoginResponse();
	+ explicit constexpr WalletLoginResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ WalletLoginResponse(const WalletLoginResponse& from);
	+ WalletLoginResponse(WalletLoginResponse&& from) noexcept
	+ : WalletLoginResponse() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline WalletLoginResponse& operator=(const WalletLoginResponse& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline WalletLoginResponse& operator=(WalletLoginResponse&& 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 WalletLoginResponse& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const WalletLoginResponse* internal_default_instance() {
	+ return reinterpret_cast<const WalletLoginResponse*>(
	+ &_WalletLoginResponse_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 6;
	+
	+ friend void swap(WalletLoginResponse& a, WalletLoginResponse& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(WalletLoginResponse* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(WalletLoginResponse* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline WalletLoginResponse* New() const final {
	+ return CreateMaybeMessage<WalletLoginResponse>(nullptr);
	+ }
	+
	+ WalletLoginResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<WalletLoginResponse>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const WalletLoginResponse& from);
	+ void MergeFrom(const WalletLoginResponse& 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(WalletLoginResponse* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.WalletLoginResponse";
	+ }
	+ protected:
	+ explicit WalletLoginResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kAccessTokenFieldNumber = 1,
	+ };
	+ // string accessToken = 1;
	+ void clear_accesstoken();
	+ const std::string& accesstoken() const;
	+ void set_accesstoken(const std::string& value);
	+ void set_accesstoken(std::string&& value);
	+ void set_accesstoken(const char* value);
	+ void set_accesstoken(const char* value, size_t size);
	+ std::string* mutable_accesstoken();
	+ std::string* release_accesstoken();
	+ void set_allocated_accesstoken(std::string* accesstoken);
	+ private:
	+ const std::string& _internal_accesstoken() const;
	+ void _internal_set_accesstoken(const std::string& value);
	+ std::string* _internal_mutable_accesstoken();
	+ public:
	+
	+ // @@protoc_insertion_point(class_scope:identity.WalletLoginResponse)
	+ private:
	+ class _Internal;
	+
	+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	+ typedef void InternalArenaConstructable_;
	+ typedef void DestructorSkippable_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accesstoken_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class RegistrationRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.RegistrationRequest) */ {
	+ public:
	+ inline RegistrationRequest() : RegistrationRequest(nullptr) {}
	+ virtual ~RegistrationRequest();
	+ explicit constexpr RegistrationRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ RegistrationRequest(const RegistrationRequest& from);
	+ RegistrationRequest(RegistrationRequest&& from) noexcept
	+ : RegistrationRequest() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline RegistrationRequest& operator=(const RegistrationRequest& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline RegistrationRequest& operator=(RegistrationRequest&& 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 RegistrationRequest& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ enum DataCase {
	+ kPakeRegistrationRequestAndUserID = 1,
	+ kPakeRegistrationUploadAndCredentialRequest = 2,
	+ kPakeCredentialFinalization = 3,
	+ DATA_NOT_SET = 0,
	+ };
	+
	+ static inline const RegistrationRequest* internal_default_instance() {
	+ return reinterpret_cast<const RegistrationRequest*>(
	+ &_RegistrationRequest_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 7;
	+
	+ friend void swap(RegistrationRequest& a, RegistrationRequest& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(RegistrationRequest* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(RegistrationRequest* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline RegistrationRequest* New() const final {
	+ return CreateMaybeMessage<RegistrationRequest>(nullptr);
	+ }
	+
	+ RegistrationRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<RegistrationRequest>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const RegistrationRequest& from);
	+ void MergeFrom(const RegistrationRequest& 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(RegistrationRequest* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.RegistrationRequest";
	+ }
	+ protected:
	+ explicit RegistrationRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kPakeRegistrationRequestAndUserIDFieldNumber = 1,
	+ kPakeRegistrationUploadAndCredentialRequestFieldNumber = 2,
	+ kPakeCredentialFinalizationFieldNumber = 3,
	+ };
	+ // .identity.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
	+ bool has_pakeregistrationrequestanduserid() const;
	+ private:
	+ bool _internal_has_pakeregistrationrequestanduserid() const;
	+ public:
	+ void clear_pakeregistrationrequestanduserid();
	+ const ::identity::PakeRegistrationRequestAndUserID& pakeregistrationrequestanduserid() const;
	+ ::identity::PakeRegistrationRequestAndUserID* release_pakeregistrationrequestanduserid();
	+ ::identity::PakeRegistrationRequestAndUserID* mutable_pakeregistrationrequestanduserid();
	+ void set_allocated_pakeregistrationrequestanduserid(::identity::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid);
	+ private:
	+ const ::identity::PakeRegistrationRequestAndUserID& _internal_pakeregistrationrequestanduserid() const;
	+ ::identity::PakeRegistrationRequestAndUserID* _internal_mutable_pakeregistrationrequestanduserid();
	+ public:
	+ void unsafe_arena_set_allocated_pakeregistrationrequestanduserid(
	+ ::identity::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid);
	+ ::identity::PakeRegistrationRequestAndUserID* unsafe_arena_release_pakeregistrationrequestanduserid();
	+
	+ // .identity.PakeRegistrationUploadAndCredentialRequest pakeRegistrationUploadAndCredentialRequest = 2;
	+ bool has_pakeregistrationuploadandcredentialrequest() const;
	+ private:
	+ bool _internal_has_pakeregistrationuploadandcredentialrequest() const;
	+ public:
	+ void clear_pakeregistrationuploadandcredentialrequest();
	+ const ::identity::PakeRegistrationUploadAndCredentialRequest& pakeregistrationuploadandcredentialrequest() const;
	+ ::identity::PakeRegistrationUploadAndCredentialRequest* release_pakeregistrationuploadandcredentialrequest();
	+ ::identity::PakeRegistrationUploadAndCredentialRequest* mutable_pakeregistrationuploadandcredentialrequest();
	+ void set_allocated_pakeregistrationuploadandcredentialrequest(::identity::PakeRegistrationUploadAndCredentialRequest* pakeregistrationuploadandcredentialrequest);
	+ private:
	+ const ::identity::PakeRegistrationUploadAndCredentialRequest& _internal_pakeregistrationuploadandcredentialrequest() const;
	+ ::identity::PakeRegistrationUploadAndCredentialRequest* _internal_mutable_pakeregistrationuploadandcredentialrequest();
	+ public:
	+ void unsafe_arena_set_allocated_pakeregistrationuploadandcredentialrequest(
	+ ::identity::PakeRegistrationUploadAndCredentialRequest* pakeregistrationuploadandcredentialrequest);
	+ ::identity::PakeRegistrationUploadAndCredentialRequest* unsafe_arena_release_pakeregistrationuploadandcredentialrequest();
	+
	+ // bytes pakeCredentialFinalization = 3;
	+ 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:
	+
	+ void clear_data();
	+ DataCase data_case() const;
	+ // @@protoc_insertion_point(class_scope:identity.RegistrationRequest)
	+ private:
	+ class _Internal;
	+ void set_has_pakeregistrationrequestanduserid();
	+ void set_has_pakeregistrationuploadandcredentialrequest();
	+ void set_has_pakecredentialfinalization();
	+
	+ 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_;
	+ ::identity::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid_;
	+ ::identity::PakeRegistrationUploadAndCredentialRequest* pakeregistrationuploadandcredentialrequest_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialfinalization_;
	+ } data_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class RegistrationResponse PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.RegistrationResponse) */ {
	+ public:
	+ inline RegistrationResponse() : RegistrationResponse(nullptr) {}
	+ virtual ~RegistrationResponse();
	+ explicit constexpr RegistrationResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ RegistrationResponse(const RegistrationResponse& from);
	+ RegistrationResponse(RegistrationResponse&& from) noexcept
	+ : RegistrationResponse() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline RegistrationResponse& operator=(const RegistrationResponse& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline RegistrationResponse& operator=(RegistrationResponse&& 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 RegistrationResponse& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ enum DataCase {
	+ kPakeRegistrationResponse = 1,
	+ kPakeLoginResponse = 2,
	+ DATA_NOT_SET = 0,
	+ };
	+
	+ static inline const RegistrationResponse* internal_default_instance() {
	+ return reinterpret_cast<const RegistrationResponse*>(
	+ &_RegistrationResponse_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 8;
	+
	+ friend void swap(RegistrationResponse& a, RegistrationResponse& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(RegistrationResponse* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(RegistrationResponse* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline RegistrationResponse* New() const final {
	+ return CreateMaybeMessage<RegistrationResponse>(nullptr);
	+ }
	+
	+ RegistrationResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<RegistrationResponse>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const RegistrationResponse& from);
	+ void MergeFrom(const RegistrationResponse& 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(RegistrationResponse* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.RegistrationResponse";
	+ }
	+ protected:
	+ explicit RegistrationResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kPakeRegistrationResponseFieldNumber = 1,
	+ kPakeLoginResponseFieldNumber = 2,
	+ };
	+ // bytes pakeRegistrationResponse = 1;
	+ bool has_pakeregistrationresponse() const;
	+ private:
	+ 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:
	+
	+ // .identity.PakeLoginResponse pakeLoginResponse = 2;
	+ bool has_pakeloginresponse() const;
	+ private:
	+ bool _internal_has_pakeloginresponse() const;
	+ public:
	+ void clear_pakeloginresponse();
	+ const ::identity::PakeLoginResponse& pakeloginresponse() const;
	+ ::identity::PakeLoginResponse* release_pakeloginresponse();
	+ ::identity::PakeLoginResponse* mutable_pakeloginresponse();
	+ void set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse);
	+ private:
	+ const ::identity::PakeLoginResponse& _internal_pakeloginresponse() const;
	+ ::identity::PakeLoginResponse* _internal_mutable_pakeloginresponse();
	+ public:
	+ void unsafe_arena_set_allocated_pakeloginresponse(
	+ ::identity::PakeLoginResponse* pakeloginresponse);
	+ ::identity::PakeLoginResponse* unsafe_arena_release_pakeloginresponse();
	+
	+ void clear_data();
	+ DataCase data_case() const;
	+ // @@protoc_insertion_point(class_scope:identity.RegistrationResponse)
	+ private:
	+ class _Internal;
	+ void set_has_pakeregistrationresponse();
	+ void set_has_pakeloginresponse();
	+
	+ 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 pakeregistrationresponse_;
	+ ::identity::PakeLoginResponse* pakeloginresponse_;
	+ } data_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class LoginRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.LoginRequest) */ {
	+ public:
	+ inline LoginRequest() : LoginRequest(nullptr) {}
	+ virtual ~LoginRequest();
	+ explicit constexpr LoginRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ LoginRequest(const LoginRequest& from);
	+ LoginRequest(LoginRequest&& from) noexcept
	+ : LoginRequest() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline LoginRequest& operator=(const LoginRequest& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline LoginRequest& operator=(LoginRequest&& 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 LoginRequest& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ enum DataCase {
	+ kPakeLoginRequest = 1,
	+ kWalletLoginRequest = 2,
	+ DATA_NOT_SET = 0,
	+ };
	+
	+ static inline const LoginRequest* internal_default_instance() {
	+ return reinterpret_cast<const LoginRequest*>(
	+ &_LoginRequest_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 9;
	+
	+ friend void swap(LoginRequest& a, LoginRequest& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(LoginRequest* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(LoginRequest* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline LoginRequest* New() const final {
	+ return CreateMaybeMessage<LoginRequest>(nullptr);
	+ }
	+
	+ LoginRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<LoginRequest>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const LoginRequest& from);
	+ void MergeFrom(const LoginRequest& 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(LoginRequest* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.LoginRequest";
	+ }
	+ protected:
	+ explicit LoginRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kPakeLoginRequestFieldNumber = 1,
	+ kWalletLoginRequestFieldNumber = 2,
	+ };
	+ // .identity.PakeLoginRequest pakeLoginRequest = 1;
	+ bool has_pakeloginrequest() const;
	+ private:
	+ bool _internal_has_pakeloginrequest() const;
	+ public:
	+ void clear_pakeloginrequest();
	+ const ::identity::PakeLoginRequest& pakeloginrequest() const;
	+ ::identity::PakeLoginRequest* release_pakeloginrequest();
	+ ::identity::PakeLoginRequest* mutable_pakeloginrequest();
	+ void set_allocated_pakeloginrequest(::identity::PakeLoginRequest* pakeloginrequest);
	+ private:
	+ const ::identity::PakeLoginRequest& _internal_pakeloginrequest() const;
	+ ::identity::PakeLoginRequest* _internal_mutable_pakeloginrequest();
	+ public:
	+ void unsafe_arena_set_allocated_pakeloginrequest(
	+ ::identity::PakeLoginRequest* pakeloginrequest);
	+ ::identity::PakeLoginRequest* unsafe_arena_release_pakeloginrequest();
	+
	+ // .identity.WalletLoginRequest walletLoginRequest = 2;
	+ bool has_walletloginrequest() const;
	+ private:
	+ bool _internal_has_walletloginrequest() const;
	+ public:
	+ void clear_walletloginrequest();
	+ const ::identity::WalletLoginRequest& walletloginrequest() const;
	+ ::identity::WalletLoginRequest* release_walletloginrequest();
	+ ::identity::WalletLoginRequest* mutable_walletloginrequest();
	+ void set_allocated_walletloginrequest(::identity::WalletLoginRequest* walletloginrequest);
	+ private:
	+ const ::identity::WalletLoginRequest& _internal_walletloginrequest() const;
	+ ::identity::WalletLoginRequest* _internal_mutable_walletloginrequest();
	+ public:
	+ void unsafe_arena_set_allocated_walletloginrequest(
	+ ::identity::WalletLoginRequest* walletloginrequest);
	+ ::identity::WalletLoginRequest* unsafe_arena_release_walletloginrequest();
	+
	+ void clear_data();
	+ DataCase data_case() const;
	+ // @@protoc_insertion_point(class_scope:identity.LoginRequest)
	+ private:
	+ class _Internal;
	+ void set_has_pakeloginrequest();
	+ void set_has_walletloginrequest();
	+
	+ 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_;
	+ ::identity::PakeLoginRequest* pakeloginrequest_;
	+ ::identity::WalletLoginRequest* walletloginrequest_;
	+ } data_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class LoginResponse PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.LoginResponse) */ {
	+ public:
	+ inline LoginResponse() : LoginResponse(nullptr) {}
	+ virtual ~LoginResponse();
	+ explicit constexpr LoginResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ LoginResponse(const LoginResponse& from);
	+ LoginResponse(LoginResponse&& from) noexcept
	+ : LoginResponse() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline LoginResponse& operator=(const LoginResponse& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline LoginResponse& operator=(LoginResponse&& 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 LoginResponse& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ enum DataCase {
	+ kPakeLoginResponse = 1,
	+ kWalletLoginResponse = 2,
	+ DATA_NOT_SET = 0,
	+ };
	+
	+ static inline const LoginResponse* internal_default_instance() {
	+ return reinterpret_cast<const LoginResponse*>(
	+ &_LoginResponse_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 10;
	+
	+ friend void swap(LoginResponse& a, LoginResponse& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(LoginResponse* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(LoginResponse* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline LoginResponse* New() const final {
	+ return CreateMaybeMessage<LoginResponse>(nullptr);
	+ }
	+
	+ LoginResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<LoginResponse>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const LoginResponse& from);
	+ void MergeFrom(const LoginResponse& 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(LoginResponse* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.LoginResponse";
	+ }
	+ protected:
	+ explicit LoginResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kPakeLoginResponseFieldNumber = 1,
	+ kWalletLoginResponseFieldNumber = 2,
	+ };
	+ // .identity.PakeLoginResponse pakeLoginResponse = 1;
	+ bool has_pakeloginresponse() const;
	+ private:
	+ bool _internal_has_pakeloginresponse() const;
	+ public:
	+ void clear_pakeloginresponse();
	+ const ::identity::PakeLoginResponse& pakeloginresponse() const;
	+ ::identity::PakeLoginResponse* release_pakeloginresponse();
	+ ::identity::PakeLoginResponse* mutable_pakeloginresponse();
	+ void set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse);
	+ private:
	+ const ::identity::PakeLoginResponse& _internal_pakeloginresponse() const;
	+ ::identity::PakeLoginResponse* _internal_mutable_pakeloginresponse();
	+ public:
	+ void unsafe_arena_set_allocated_pakeloginresponse(
	+ ::identity::PakeLoginResponse* pakeloginresponse);
	+ ::identity::PakeLoginResponse* unsafe_arena_release_pakeloginresponse();
	+
	+ // .identity.WalletLoginResponse walletLoginResponse = 2;
	+ bool has_walletloginresponse() const;
	+ private:
	+ bool _internal_has_walletloginresponse() const;
	+ public:
	+ void clear_walletloginresponse();
	+ const ::identity::WalletLoginResponse& walletloginresponse() const;
	+ ::identity::WalletLoginResponse* release_walletloginresponse();
	+ ::identity::WalletLoginResponse* mutable_walletloginresponse();
	+ void set_allocated_walletloginresponse(::identity::WalletLoginResponse* walletloginresponse);
	+ private:
	+ const ::identity::WalletLoginResponse& _internal_walletloginresponse() const;
	+ ::identity::WalletLoginResponse* _internal_mutable_walletloginresponse();
	+ public:
	+ void unsafe_arena_set_allocated_walletloginresponse(
	+ ::identity::WalletLoginResponse* walletloginresponse);
	+ ::identity::WalletLoginResponse* unsafe_arena_release_walletloginresponse();
	+
	+ void clear_data();
	+ DataCase data_case() const;
	+ // @@protoc_insertion_point(class_scope:identity.LoginResponse)
	+ private:
	+ class _Internal;
	+ void set_has_pakeloginresponse();
	+ void set_has_walletloginresponse();
	+
	+ 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_;
	+ ::identity::PakeLoginResponse* pakeloginresponse_;
	+ ::identity::WalletLoginResponse* walletloginresponse_;
	+ } data_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
	+
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class VerifyUserTokenRequest PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.VerifyUserTokenRequest) */ {
	+ public:
	+ inline VerifyUserTokenRequest() : VerifyUserTokenRequest(nullptr) {}
	+ virtual ~VerifyUserTokenRequest();
	+ explicit constexpr VerifyUserTokenRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ VerifyUserTokenRequest(const VerifyUserTokenRequest& from);
	+ VerifyUserTokenRequest(VerifyUserTokenRequest&& from) noexcept
	+ : VerifyUserTokenRequest() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline VerifyUserTokenRequest& operator=(const VerifyUserTokenRequest& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline VerifyUserTokenRequest& operator=(VerifyUserTokenRequest&& 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 VerifyUserTokenRequest& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const VerifyUserTokenRequest* internal_default_instance() {
	+ return reinterpret_cast<const VerifyUserTokenRequest*>(
	+ &_VerifyUserTokenRequest_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 11;
	+
	+ friend void swap(VerifyUserTokenRequest& a, VerifyUserTokenRequest& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(VerifyUserTokenRequest* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(VerifyUserTokenRequest* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline VerifyUserTokenRequest* New() const final {
	+ return CreateMaybeMessage<VerifyUserTokenRequest>(nullptr);
	+ }
	+
	+ VerifyUserTokenRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<VerifyUserTokenRequest>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const VerifyUserTokenRequest& from);
	+ void MergeFrom(const VerifyUserTokenRequest& 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(VerifyUserTokenRequest* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.VerifyUserTokenRequest";
	+ }
	+ protected:
	+ explicit VerifyUserTokenRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kUserIDFieldNumber = 1,
	+ kDeviceIDFieldNumber = 2,
	+ kAccessTokenFieldNumber = 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);
	+ private:
	+ const std::string& _internal_userid() const;
	+ void _internal_set_userid(const std::string& value);
	+ std::string* _internal_mutable_userid();
	+ public:
	+
	+ // string deviceID = 2;
	+ void clear_deviceid();
	+ const std::string& deviceid() const;
	+ void set_deviceid(const std::string& value);
	+ void set_deviceid(std::string&& value);
	+ void set_deviceid(const char* value);
	+ void set_deviceid(const char* value, size_t size);
	+ std::string* mutable_deviceid();
	+ std::string* release_deviceid();
	+ void set_allocated_deviceid(std::string* deviceid);
	+ private:
	+ const std::string& _internal_deviceid() const;
	+ void _internal_set_deviceid(const std::string& value);
	+ std::string* _internal_mutable_deviceid();
	+ public:
	+
	+ // string accessToken = 3;
	+ void clear_accesstoken();
	+ const std::string& accesstoken() const;
	+ void set_accesstoken(const std::string& value);
	+ void set_accesstoken(std::string&& value);
	+ void set_accesstoken(const char* value);
	+ void set_accesstoken(const char* value, size_t size);
	+ std::string* mutable_accesstoken();
	+ std::string* release_accesstoken();
	+ void set_allocated_accesstoken(std::string* accesstoken);
	+ private:
	+ const std::string& _internal_accesstoken() const;
	+ void _internal_set_accesstoken(const std::string& value);
	+ std::string* _internal_mutable_accesstoken();
	+ public:
	+
	+ // @@protoc_insertion_point(class_scope:identity.VerifyUserTokenRequest)
	+ 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 deviceid_;
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accesstoken_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// -------------------------------------------------------------------
	+
	+class VerifyUserTokenResponse PROTOBUF_FINAL :
	+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.VerifyUserTokenResponse) */ {
	+ public:
	+ inline VerifyUserTokenResponse() : VerifyUserTokenResponse(nullptr) {}
	+ virtual ~VerifyUserTokenResponse();
	+ explicit constexpr VerifyUserTokenResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
	+
	+ VerifyUserTokenResponse(const VerifyUserTokenResponse& from);
	+ VerifyUserTokenResponse(VerifyUserTokenResponse&& from) noexcept
	+ : VerifyUserTokenResponse() {
	+ *this = ::std::move(from);
	+ }
	+
	+ inline VerifyUserTokenResponse& operator=(const VerifyUserTokenResponse& from) {
	+ CopyFrom(from);
	+ return *this;
	+ }
	+ inline VerifyUserTokenResponse& operator=(VerifyUserTokenResponse&& 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 VerifyUserTokenResponse& default_instance() {
	+ return *internal_default_instance();
	+ }
	+ static inline const VerifyUserTokenResponse* internal_default_instance() {
	+ return reinterpret_cast<const VerifyUserTokenResponse*>(
	+ &_VerifyUserTokenResponse_default_instance_);
	+ }
	+ static constexpr int kIndexInFileMessages =
	+ 12;
	+
	+ friend void swap(VerifyUserTokenResponse& a, VerifyUserTokenResponse& b) {
	+ a.Swap(&b);
	+ }
	+ inline void Swap(VerifyUserTokenResponse* other) {
	+ if (other == this) return;
	+ if (GetArena() == other->GetArena()) {
	+ InternalSwap(other);
	+ } else {
	+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
	+ }
	+ }
	+ void UnsafeArenaSwap(VerifyUserTokenResponse* other) {
	+ if (other == this) return;
	+ GOOGLE_DCHECK(GetArena() == other->GetArena());
	+ InternalSwap(other);
	+ }
	+
	+ // implements Message ----------------------------------------------
	+
	+ inline VerifyUserTokenResponse* New() const final {
	+ return CreateMaybeMessage<VerifyUserTokenResponse>(nullptr);
	+ }
	+
	+ VerifyUserTokenResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
	+ return CreateMaybeMessage<VerifyUserTokenResponse>(arena);
	+ }
	+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
	+ void CopyFrom(const VerifyUserTokenResponse& from);
	+ void MergeFrom(const VerifyUserTokenResponse& 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(VerifyUserTokenResponse* other);
	+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
	+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
	+ return "identity.VerifyUserTokenResponse";
	+ }
	+ protected:
	+ explicit VerifyUserTokenResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
	+ }
	+
	+ public:
	+
	+ // nested types ----------------------------------------------------
	+
	+ // accessors -------------------------------------------------------
	+
	+ enum : int {
	+ kTokenValidFieldNumber = 1,
	+ };
	+ // bool tokenValid = 1;
	+ void clear_tokenvalid();
	+ bool tokenvalid() const;
	+ void set_tokenvalid(bool value);
	+ private:
	+ bool _internal_tokenvalid() const;
	+ void _internal_set_tokenvalid(bool value);
	+ public:
	+
	+ // @@protoc_insertion_point(class_scope:identity.VerifyUserTokenResponse)
	+ private:
	+ class _Internal;
	+
	+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
	+ typedef void InternalArenaConstructable_;
	+ typedef void DestructorSkippable_;
	+ bool tokenvalid_;
	+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
	+ friend struct ::TableStruct_identity_2eproto;
	+};
	+// ===================================================================
	+
	+
	+// ===================================================================
	+
	+#ifdef __GNUC__
	+ #pragma GCC diagnostic push
	+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
	+#endif // __GNUC__
	+// PakeRegistrationRequestAndUserID
	+
	+// string userID = 1;
	+inline void PakeRegistrationRequestAndUserID::clear_userid() {
	+ userid_.ClearToEmpty();
	+}
	+inline const std::string& PakeRegistrationRequestAndUserID::userid() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeRegistrationRequestAndUserID.userID)
	+ return _internal_userid();
	+}
	+inline void PakeRegistrationRequestAndUserID::set_userid(const std::string& value) {
	+ _internal_set_userid(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeRegistrationRequestAndUserID.userID)
	+}
	+inline std::string* PakeRegistrationRequestAndUserID::mutable_userid() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeRegistrationRequestAndUserID.userID)
	+ return _internal_mutable_userid();
	+}
	+inline const std::string& PakeRegistrationRequestAndUserID::_internal_userid() const {
	+ return userid_.Get();
	+}
	+inline void PakeRegistrationRequestAndUserID::_internal_set_userid(const std::string& value) {
	+
	+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeRegistrationRequestAndUserID::set_userid(std::string&& value) {
	+
	+ userid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeRegistrationRequestAndUserID.userID)
	+}
	+inline void PakeRegistrationRequestAndUserID::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:identity.PakeRegistrationRequestAndUserID.userID)
	+}
	+inline void PakeRegistrationRequestAndUserID::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:identity.PakeRegistrationRequestAndUserID.userID)
	+}
	+inline std::string* PakeRegistrationRequestAndUserID::_internal_mutable_userid() {
	+
	+ return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeRegistrationRequestAndUserID::release_userid() {
	+ // @@protoc_insertion_point(field_release:identity.PakeRegistrationRequestAndUserID.userID)
	+ return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void PakeRegistrationRequestAndUserID::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:identity.PakeRegistrationRequestAndUserID.userID)
	+}
	+
	+// string deviceID = 2;
	+inline void PakeRegistrationRequestAndUserID::clear_deviceid() {
	+ deviceid_.ClearToEmpty();
	+}
	+inline const std::string& PakeRegistrationRequestAndUserID::deviceid() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeRegistrationRequestAndUserID.deviceID)
	+ return _internal_deviceid();
	+}
	+inline void PakeRegistrationRequestAndUserID::set_deviceid(const std::string& value) {
	+ _internal_set_deviceid(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeRegistrationRequestAndUserID.deviceID)
	+}
	+inline std::string* PakeRegistrationRequestAndUserID::mutable_deviceid() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeRegistrationRequestAndUserID.deviceID)
	+ return _internal_mutable_deviceid();
	+}
	+inline const std::string& PakeRegistrationRequestAndUserID::_internal_deviceid() const {
	+ return deviceid_.Get();
	+}
	+inline void PakeRegistrationRequestAndUserID::_internal_set_deviceid(const std::string& value) {
	+
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeRegistrationRequestAndUserID::set_deviceid(std::string&& value) {
	+
	+ deviceid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeRegistrationRequestAndUserID.deviceID)
	+}
	+inline void PakeRegistrationRequestAndUserID::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:identity.PakeRegistrationRequestAndUserID.deviceID)
	+}
	+inline void PakeRegistrationRequestAndUserID::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:identity.PakeRegistrationRequestAndUserID.deviceID)
	+}
	+inline std::string* PakeRegistrationRequestAndUserID::_internal_mutable_deviceid() {
	+
	+ return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeRegistrationRequestAndUserID::release_deviceid() {
	+ // @@protoc_insertion_point(field_release:identity.PakeRegistrationRequestAndUserID.deviceID)
	+ return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void PakeRegistrationRequestAndUserID::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:identity.PakeRegistrationRequestAndUserID.deviceID)
	+}
	+
	+// bytes pakeRegistrationRequest = 3;
	+inline void PakeRegistrationRequestAndUserID::clear_pakeregistrationrequest() {
	+ pakeregistrationrequest_.ClearToEmpty();
	+}
	+inline const std::string& PakeRegistrationRequestAndUserID::pakeregistrationrequest() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
	+ return _internal_pakeregistrationrequest();
	+}
	+inline void PakeRegistrationRequestAndUserID::set_pakeregistrationrequest(const std::string& value) {
	+ _internal_set_pakeregistrationrequest(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
	+}
	+inline std::string* PakeRegistrationRequestAndUserID::mutable_pakeregistrationrequest() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
	+ return _internal_mutable_pakeregistrationrequest();
	+}
	+inline const std::string& PakeRegistrationRequestAndUserID::_internal_pakeregistrationrequest() const {
	+ return pakeregistrationrequest_.Get();
	+}
	+inline void PakeRegistrationRequestAndUserID::_internal_set_pakeregistrationrequest(const std::string& value) {
	+
	+ pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeRegistrationRequestAndUserID::set_pakeregistrationrequest(std::string&& value) {
	+
	+ pakeregistrationrequest_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
	+}
	+inline void PakeRegistrationRequestAndUserID::set_pakeregistrationrequest(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
	+}
	+inline void PakeRegistrationRequestAndUserID::set_pakeregistrationrequest(const void* value,
	+ size_t size) {
	+
	+ pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
	+}
	+inline std::string* PakeRegistrationRequestAndUserID::_internal_mutable_pakeregistrationrequest() {
	+
	+ return pakeregistrationrequest_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeRegistrationRequestAndUserID::release_pakeregistrationrequest() {
	+ // @@protoc_insertion_point(field_release:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
	+ return pakeregistrationrequest_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void PakeRegistrationRequestAndUserID::set_allocated_pakeregistrationrequest(std::string* pakeregistrationrequest) {
	+ if (pakeregistrationrequest != nullptr) {
	+
	+ } else {
	+
	+ }
	+ pakeregistrationrequest_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakeregistrationrequest,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
	+}
	+
	+// -------------------------------------------------------------------
	+
	+// PakeCredentialRequestAndUserID
	+
	+// string userID = 1;
	+inline void PakeCredentialRequestAndUserID::clear_userid() {
	+ userid_.ClearToEmpty();
	+}
	+inline const std::string& PakeCredentialRequestAndUserID::userid() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeCredentialRequestAndUserID.userID)
	+ return _internal_userid();
	+}
	+inline void PakeCredentialRequestAndUserID::set_userid(const std::string& value) {
	+ _internal_set_userid(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeCredentialRequestAndUserID.userID)
	+}
	+inline std::string* PakeCredentialRequestAndUserID::mutable_userid() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeCredentialRequestAndUserID.userID)
	+ return _internal_mutable_userid();
	+}
	+inline const std::string& PakeCredentialRequestAndUserID::_internal_userid() const {
	+ return userid_.Get();
	+}
	+inline void PakeCredentialRequestAndUserID::_internal_set_userid(const std::string& value) {
	+
	+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeCredentialRequestAndUserID::set_userid(std::string&& value) {
	+
	+ userid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeCredentialRequestAndUserID.userID)
	+}
	+inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.userID)
	+}
	+inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.userID)
	+}
	+inline std::string* PakeCredentialRequestAndUserID::_internal_mutable_userid() {
	+
	+ return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeCredentialRequestAndUserID::release_userid() {
	+ // @@protoc_insertion_point(field_release:identity.PakeCredentialRequestAndUserID.userID)
	+ return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.userID)
	+}
	+
	+// string deviceID = 2;
	+inline void PakeCredentialRequestAndUserID::clear_deviceid() {
	+ deviceid_.ClearToEmpty();
	+}
	+inline const std::string& PakeCredentialRequestAndUserID::deviceid() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeCredentialRequestAndUserID.deviceID)
	+ return _internal_deviceid();
	+}
	+inline void PakeCredentialRequestAndUserID::set_deviceid(const std::string& value) {
	+ _internal_set_deviceid(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeCredentialRequestAndUserID.deviceID)
	+}
	+inline std::string* PakeCredentialRequestAndUserID::mutable_deviceid() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeCredentialRequestAndUserID.deviceID)
	+ return _internal_mutable_deviceid();
	+}
	+inline const std::string& PakeCredentialRequestAndUserID::_internal_deviceid() const {
	+ return deviceid_.Get();
	+}
	+inline void PakeCredentialRequestAndUserID::_internal_set_deviceid(const std::string& value) {
	+
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeCredentialRequestAndUserID::set_deviceid(std::string&& value) {
	+
	+ deviceid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeCredentialRequestAndUserID.deviceID)
	+}
	+inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.deviceID)
	+}
	+inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.deviceID)
	+}
	+inline std::string* PakeCredentialRequestAndUserID::_internal_mutable_deviceid() {
	+
	+ return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeCredentialRequestAndUserID::release_deviceid() {
	+ // @@protoc_insertion_point(field_release:identity.PakeCredentialRequestAndUserID.deviceID)
	+ return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.deviceID)
	+}
	+
	+// bytes pakeCredentialRequest = 3;
	+inline void PakeCredentialRequestAndUserID::clear_pakecredentialrequest() {
	+ pakecredentialrequest_.ClearToEmpty();
	+}
	+inline const std::string& PakeCredentialRequestAndUserID::pakecredentialrequest() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
	+ return _internal_pakecredentialrequest();
	+}
	+inline void PakeCredentialRequestAndUserID::set_pakecredentialrequest(const std::string& value) {
	+ _internal_set_pakecredentialrequest(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
	+}
	+inline std::string* PakeCredentialRequestAndUserID::mutable_pakecredentialrequest() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
	+ return _internal_mutable_pakecredentialrequest();
	+}
	+inline const std::string& PakeCredentialRequestAndUserID::_internal_pakecredentialrequest() const {
	+ return pakecredentialrequest_.Get();
	+}
	+inline void PakeCredentialRequestAndUserID::_internal_set_pakecredentialrequest(const std::string& value) {
	+
	+ pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeCredentialRequestAndUserID::set_pakecredentialrequest(std::string&& value) {
	+
	+ pakecredentialrequest_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
	+}
	+inline void PakeCredentialRequestAndUserID::set_pakecredentialrequest(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
	+}
	+inline void PakeCredentialRequestAndUserID::set_pakecredentialrequest(const void* value,
	+ size_t size) {
	+
	+ pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
	+}
	+inline std::string* PakeCredentialRequestAndUserID::_internal_mutable_pakecredentialrequest() {
	+
	+ return pakecredentialrequest_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeCredentialRequestAndUserID::release_pakecredentialrequest() {
	+ // @@protoc_insertion_point(field_release:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
	+ return pakecredentialrequest_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void PakeCredentialRequestAndUserID::set_allocated_pakecredentialrequest(std::string* pakecredentialrequest) {
	+ if (pakecredentialrequest != nullptr) {
	+
	+ } else {
	+
	+ }
	+ pakecredentialrequest_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakecredentialrequest,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
	+}
	+
	+// -------------------------------------------------------------------
	+
	+// PakeLoginRequest
	+
	+// .identity.PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
	+inline bool PakeLoginRequest::_internal_has_pakecredentialrequestanduserid() const {
	+ return data_case() == kPakeCredentialRequestAndUserID;
	+}
	+inline bool PakeLoginRequest::has_pakecredentialrequestanduserid() const {
	+ return _internal_has_pakecredentialrequestanduserid();
	+}
	+inline void PakeLoginRequest::set_has_pakecredentialrequestanduserid() {
	+ _oneof_case_[0] = kPakeCredentialRequestAndUserID;
	+}
	+inline void PakeLoginRequest::clear_pakecredentialrequestanduserid() {
	+ if (_internal_has_pakecredentialrequestanduserid()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakecredentialrequestanduserid_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::identity::PakeCredentialRequestAndUserID* PakeLoginRequest::release_pakecredentialrequestanduserid() {
	+ // @@protoc_insertion_point(field_release:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
	+ if (_internal_has_pakecredentialrequestanduserid()) {
	+ clear_has_data();
	+ ::identity::PakeCredentialRequestAndUserID* temp = data_.pakecredentialrequestanduserid_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.pakecredentialrequestanduserid_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::identity::PakeCredentialRequestAndUserID& PakeLoginRequest::_internal_pakecredentialrequestanduserid() const {
	+ return _internal_has_pakecredentialrequestanduserid()
	+ ? *data_.pakecredentialrequestanduserid_
	+ : reinterpret_cast< ::identity::PakeCredentialRequestAndUserID&>(::identity::_PakeCredentialRequestAndUserID_default_instance_);
	+}
	+inline const ::identity::PakeCredentialRequestAndUserID& PakeLoginRequest::pakecredentialrequestanduserid() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
	+ return _internal_pakecredentialrequestanduserid();
	+}
	+inline ::identity::PakeCredentialRequestAndUserID* PakeLoginRequest::unsafe_arena_release_pakecredentialrequestanduserid() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
	+ if (_internal_has_pakecredentialrequestanduserid()) {
	+ clear_has_data();
	+ ::identity::PakeCredentialRequestAndUserID* temp = data_.pakecredentialrequestanduserid_;
	+ data_.pakecredentialrequestanduserid_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void PakeLoginRequest::unsafe_arena_set_allocated_pakecredentialrequestanduserid(::identity::PakeCredentialRequestAndUserID* pakecredentialrequestanduserid) {
	+ clear_data();
	+ if (pakecredentialrequestanduserid) {
	+ set_has_pakecredentialrequestanduserid();
	+ data_.pakecredentialrequestanduserid_ = pakecredentialrequestanduserid;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
	+}
	+inline ::identity::PakeCredentialRequestAndUserID* PakeLoginRequest::_internal_mutable_pakecredentialrequestanduserid() {
	+ if (!_internal_has_pakecredentialrequestanduserid()) {
	+ clear_data();
	+ set_has_pakecredentialrequestanduserid();
	+ data_.pakecredentialrequestanduserid_ = CreateMaybeMessage< ::identity::PakeCredentialRequestAndUserID >(GetArena());
	+ }
	+ return data_.pakecredentialrequestanduserid_;
	+}
	+inline ::identity::PakeCredentialRequestAndUserID* PakeLoginRequest::mutable_pakecredentialrequestanduserid() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
	+ return _internal_mutable_pakecredentialrequestanduserid();
	+}
	+
	+// bytes pakeCredentialFinalization = 2;
	+inline bool PakeLoginRequest::_internal_has_pakecredentialfinalization() const {
	+ return data_case() == kPakeCredentialFinalization;
	+}
	+inline bool PakeLoginRequest::has_pakecredentialfinalization() const {
	+ return _internal_has_pakecredentialfinalization();
	+}
	+inline void PakeLoginRequest::set_has_pakecredentialfinalization() {
	+ _oneof_case_[0] = kPakeCredentialFinalization;
	+}
	+inline void PakeLoginRequest::clear_pakecredentialfinalization() {
	+ if (_internal_has_pakecredentialfinalization()) {
	+ data_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_data();
	+ }
	+}
	+inline const std::string& PakeLoginRequest::pakecredentialfinalization() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeLoginRequest.pakeCredentialFinalization)
	+ return _internal_pakecredentialfinalization();
	+}
	+inline void PakeLoginRequest::set_pakecredentialfinalization(const std::string& value) {
	+ _internal_set_pakecredentialfinalization(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeLoginRequest.pakeCredentialFinalization)
	+}
	+inline std::string* PakeLoginRequest::mutable_pakecredentialfinalization() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeLoginRequest.pakeCredentialFinalization)
	+ return _internal_mutable_pakecredentialfinalization();
	+}
	+inline const std::string& PakeLoginRequest::_internal_pakecredentialfinalization() const {
	+ if (_internal_has_pakecredentialfinalization()) {
	+ return data_.pakecredentialfinalization_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void PakeLoginRequest::_internal_set_pakecredentialfinalization(const std::string& value) {
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_data();
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialfinalization_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeLoginRequest::set_pakecredentialfinalization(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:identity.PakeLoginRequest.pakeCredentialFinalization)
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_data();
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialfinalization_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeLoginRequest.pakeCredentialFinalization)
	+}
	+inline void PakeLoginRequest::set_pakecredentialfinalization(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_data();
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialfinalization_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.PakeLoginRequest.pakeCredentialFinalization)
	+}
	+inline void PakeLoginRequest::set_pakecredentialfinalization(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_data();
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialfinalization_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.PakeLoginRequest.pakeCredentialFinalization)
	+}
	+inline std::string* PakeLoginRequest::_internal_mutable_pakecredentialfinalization() {
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_data();
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return data_.pakecredentialfinalization_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeLoginRequest::release_pakecredentialfinalization() {
	+ // @@protoc_insertion_point(field_release:identity.PakeLoginRequest.pakeCredentialFinalization)
	+ if (_internal_has_pakecredentialfinalization()) {
	+ clear_has_data();
	+ return data_.pakecredentialfinalization_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void PakeLoginRequest::set_allocated_pakecredentialfinalization(std::string* pakecredentialfinalization) {
	+ if (has_data()) {
	+ clear_data();
	+ }
	+ if (pakecredentialfinalization != nullptr) {
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(pakecredentialfinalization);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakecredentialfinalization);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.PakeLoginRequest.pakeCredentialFinalization)
	+}
	+
	+inline bool PakeLoginRequest::has_data() const {
	+ return data_case() != DATA_NOT_SET;
	+}
	+inline void PakeLoginRequest::clear_has_data() {
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+inline PakeLoginRequest::DataCase PakeLoginRequest::data_case() const {
	+ return PakeLoginRequest::DataCase(_oneof_case_[0]);
	+}
	+// -------------------------------------------------------------------
	+
	+// PakeLoginResponse
	+
	+// bytes pakeCredentialResponse = 1;
	+inline bool PakeLoginResponse::_internal_has_pakecredentialresponse() const {
	+ return data_case() == kPakeCredentialResponse;
	+}
	+inline bool PakeLoginResponse::has_pakecredentialresponse() const {
	+ return _internal_has_pakecredentialresponse();
	+}
	+inline void PakeLoginResponse::set_has_pakecredentialresponse() {
	+ _oneof_case_[0] = kPakeCredentialResponse;
	+}
	+inline void PakeLoginResponse::clear_pakecredentialresponse() {
	+ if (_internal_has_pakecredentialresponse()) {
	+ data_.pakecredentialresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_data();
	+ }
	+}
	+inline const std::string& PakeLoginResponse::pakecredentialresponse() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeLoginResponse.pakeCredentialResponse)
	+ return _internal_pakecredentialresponse();
	+}
	+inline void PakeLoginResponse::set_pakecredentialresponse(const std::string& value) {
	+ _internal_set_pakecredentialresponse(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeLoginResponse.pakeCredentialResponse)
	+}
	+inline std::string* PakeLoginResponse::mutable_pakecredentialresponse() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeLoginResponse.pakeCredentialResponse)
	+ return _internal_mutable_pakecredentialresponse();
	+}
	+inline const std::string& PakeLoginResponse::_internal_pakecredentialresponse() const {
	+ if (_internal_has_pakecredentialresponse()) {
	+ return data_.pakecredentialresponse_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void PakeLoginResponse::_internal_set_pakecredentialresponse(const std::string& value) {
	+ if (!_internal_has_pakecredentialresponse()) {
	+ clear_data();
	+ set_has_pakecredentialresponse();
	+ data_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeLoginResponse::set_pakecredentialresponse(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:identity.PakeLoginResponse.pakeCredentialResponse)
	+ if (!_internal_has_pakecredentialresponse()) {
	+ clear_data();
	+ set_has_pakecredentialresponse();
	+ data_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeLoginResponse.pakeCredentialResponse)
	+}
	+inline void PakeLoginResponse::set_pakecredentialresponse(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakecredentialresponse()) {
	+ clear_data();
	+ set_has_pakecredentialresponse();
	+ data_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.PakeLoginResponse.pakeCredentialResponse)
	+}
	+inline void PakeLoginResponse::set_pakecredentialresponse(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakecredentialresponse()) {
	+ clear_data();
	+ set_has_pakecredentialresponse();
	+ data_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.PakeLoginResponse.pakeCredentialResponse)
	+}
	+inline std::string* PakeLoginResponse::_internal_mutable_pakecredentialresponse() {
	+ if (!_internal_has_pakecredentialresponse()) {
	+ clear_data();
	+ set_has_pakecredentialresponse();
	+ data_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return data_.pakecredentialresponse_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeLoginResponse::release_pakecredentialresponse() {
	+ // @@protoc_insertion_point(field_release:identity.PakeLoginResponse.pakeCredentialResponse)
	+ if (_internal_has_pakecredentialresponse()) {
	+ clear_has_data();
	+ return data_.pakecredentialresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void PakeLoginResponse::set_allocated_pakecredentialresponse(std::string* pakecredentialresponse) {
	+ if (has_data()) {
	+ clear_data();
	+ }
	+ if (pakecredentialresponse != nullptr) {
	+ set_has_pakecredentialresponse();
	+ data_.pakecredentialresponse_.UnsafeSetDefault(pakecredentialresponse);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakecredentialresponse);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.PakeLoginResponse.pakeCredentialResponse)
	+}
	+
	+// string accessToken = 2;
	+inline bool PakeLoginResponse::_internal_has_accesstoken() const {
	+ return data_case() == kAccessToken;
	+}
	+inline bool PakeLoginResponse::has_accesstoken() const {
	+ return _internal_has_accesstoken();
	+}
	+inline void PakeLoginResponse::set_has_accesstoken() {
	+ _oneof_case_[0] = kAccessToken;
	+}
	+inline void PakeLoginResponse::clear_accesstoken() {
	+ if (_internal_has_accesstoken()) {
	+ data_.accesstoken_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_data();
	+ }
	+}
	+inline const std::string& PakeLoginResponse::accesstoken() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeLoginResponse.accessToken)
	+ return _internal_accesstoken();
	+}
	+inline void PakeLoginResponse::set_accesstoken(const std::string& value) {
	+ _internal_set_accesstoken(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeLoginResponse.accessToken)
	+}
	+inline std::string* PakeLoginResponse::mutable_accesstoken() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeLoginResponse.accessToken)
	+ return _internal_mutable_accesstoken();
	+}
	+inline const std::string& PakeLoginResponse::_internal_accesstoken() const {
	+ if (_internal_has_accesstoken()) {
	+ return data_.accesstoken_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void PakeLoginResponse::_internal_set_accesstoken(const std::string& value) {
	+ if (!_internal_has_accesstoken()) {
	+ clear_data();
	+ set_has_accesstoken();
	+ data_.accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeLoginResponse::set_accesstoken(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:identity.PakeLoginResponse.accessToken)
	+ if (!_internal_has_accesstoken()) {
	+ clear_data();
	+ set_has_accesstoken();
	+ data_.accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.accesstoken_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeLoginResponse.accessToken)
	+}
	+inline void PakeLoginResponse::set_accesstoken(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_accesstoken()) {
	+ clear_data();
	+ set_has_accesstoken();
	+ data_.accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.PakeLoginResponse.accessToken)
	+}
	+inline void PakeLoginResponse::set_accesstoken(const char* value,
	+ size_t size) {
	+ if (!_internal_has_accesstoken()) {
	+ clear_data();
	+ set_has_accesstoken();
	+ data_.accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.accesstoken_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.PakeLoginResponse.accessToken)
	+}
	+inline std::string* PakeLoginResponse::_internal_mutable_accesstoken() {
	+ if (!_internal_has_accesstoken()) {
	+ clear_data();
	+ set_has_accesstoken();
	+ data_.accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return data_.accesstoken_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeLoginResponse::release_accesstoken() {
	+ // @@protoc_insertion_point(field_release:identity.PakeLoginResponse.accessToken)
	+ if (_internal_has_accesstoken()) {
	+ clear_has_data();
	+ return data_.accesstoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void PakeLoginResponse::set_allocated_accesstoken(std::string* accesstoken) {
	+ if (has_data()) {
	+ clear_data();
	+ }
	+ if (accesstoken != nullptr) {
	+ set_has_accesstoken();
	+ data_.accesstoken_.UnsafeSetDefault(accesstoken);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(accesstoken);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.PakeLoginResponse.accessToken)
	+}
	+
	+inline bool PakeLoginResponse::has_data() const {
	+ return data_case() != DATA_NOT_SET;
	+}
	+inline void PakeLoginResponse::clear_has_data() {
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+inline PakeLoginResponse::DataCase PakeLoginResponse::data_case() const {
	+ return PakeLoginResponse::DataCase(_oneof_case_[0]);
	+}
	+// -------------------------------------------------------------------
	+
	+// PakeRegistrationUploadAndCredentialRequest
	+
	+// bytes pakeRegistrationUpload = 1;
	+inline void PakeRegistrationUploadAndCredentialRequest::clear_pakeregistrationupload() {
	+ pakeregistrationupload_.ClearToEmpty();
	+}
	+inline const std::string& PakeRegistrationUploadAndCredentialRequest::pakeregistrationupload() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
	+ return _internal_pakeregistrationupload();
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::set_pakeregistrationupload(const std::string& value) {
	+ _internal_set_pakeregistrationupload(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
	+}
	+inline std::string* PakeRegistrationUploadAndCredentialRequest::mutable_pakeregistrationupload() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
	+ return _internal_mutable_pakeregistrationupload();
	+}
	+inline const std::string& PakeRegistrationUploadAndCredentialRequest::_internal_pakeregistrationupload() const {
	+ return pakeregistrationupload_.Get();
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::_internal_set_pakeregistrationupload(const std::string& value) {
	+
	+ pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::set_pakeregistrationupload(std::string&& value) {
	+
	+ pakeregistrationupload_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::set_pakeregistrationupload(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::set_pakeregistrationupload(const void* value,
	+ size_t size) {
	+
	+ pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
	+}
	+inline std::string* PakeRegistrationUploadAndCredentialRequest::_internal_mutable_pakeregistrationupload() {
	+
	+ return pakeregistrationupload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeRegistrationUploadAndCredentialRequest::release_pakeregistrationupload() {
	+ // @@protoc_insertion_point(field_release:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
	+ return pakeregistrationupload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::set_allocated_pakeregistrationupload(std::string* pakeregistrationupload) {
	+ if (pakeregistrationupload != nullptr) {
	+
	+ } else {
	+
	+ }
	+ pakeregistrationupload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakeregistrationupload,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
	+}
	+
	+// bytes pakeCredentialRequest = 2;
	+inline void PakeRegistrationUploadAndCredentialRequest::clear_pakecredentialrequest() {
	+ pakecredentialrequest_.ClearToEmpty();
	+}
	+inline const std::string& PakeRegistrationUploadAndCredentialRequest::pakecredentialrequest() const {
	+ // @@protoc_insertion_point(field_get:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
	+ return _internal_pakecredentialrequest();
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::set_pakecredentialrequest(const std::string& value) {
	+ _internal_set_pakecredentialrequest(value);
	+ // @@protoc_insertion_point(field_set:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
	+}
	+inline std::string* PakeRegistrationUploadAndCredentialRequest::mutable_pakecredentialrequest() {
	+ // @@protoc_insertion_point(field_mutable:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
	+ return _internal_mutable_pakecredentialrequest();
	+}
	+inline const std::string& PakeRegistrationUploadAndCredentialRequest::_internal_pakecredentialrequest() const {
	+ return pakecredentialrequest_.Get();
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::_internal_set_pakecredentialrequest(const std::string& value) {
	+
	+ pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::set_pakecredentialrequest(std::string&& value) {
	+
	+ pakecredentialrequest_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::set_pakecredentialrequest(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::set_pakecredentialrequest(const void* value,
	+ size_t size) {
	+
	+ pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
	+}
	+inline std::string* PakeRegistrationUploadAndCredentialRequest::_internal_mutable_pakecredentialrequest() {
	+
	+ return pakecredentialrequest_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* PakeRegistrationUploadAndCredentialRequest::release_pakecredentialrequest() {
	+ // @@protoc_insertion_point(field_release:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
	+ return pakecredentialrequest_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void PakeRegistrationUploadAndCredentialRequest::set_allocated_pakecredentialrequest(std::string* pakecredentialrequest) {
	+ if (pakecredentialrequest != nullptr) {
	+
	+ } else {
	+
	+ }
	+ pakecredentialrequest_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakecredentialrequest,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
	+}
	+
	+// -------------------------------------------------------------------
	+
	+// WalletLoginRequest
	+
	+// string userID = 1;
	+inline void WalletLoginRequest::clear_userid() {
	+ userid_.ClearToEmpty();
	+}
	+inline const std::string& WalletLoginRequest::userid() const {
	+ // @@protoc_insertion_point(field_get:identity.WalletLoginRequest.userID)
	+ return _internal_userid();
	+}
	+inline void WalletLoginRequest::set_userid(const std::string& value) {
	+ _internal_set_userid(value);
	+ // @@protoc_insertion_point(field_set:identity.WalletLoginRequest.userID)
	+}
	+inline std::string* WalletLoginRequest::mutable_userid() {
	+ // @@protoc_insertion_point(field_mutable:identity.WalletLoginRequest.userID)
	+ return _internal_mutable_userid();
	+}
	+inline const std::string& WalletLoginRequest::_internal_userid() const {
	+ return userid_.Get();
	+}
	+inline void WalletLoginRequest::_internal_set_userid(const std::string& value) {
	+
	+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void WalletLoginRequest::set_userid(std::string&& value) {
	+
	+ userid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginRequest.userID)
	+}
	+inline void WalletLoginRequest::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:identity.WalletLoginRequest.userID)
	+}
	+inline void WalletLoginRequest::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:identity.WalletLoginRequest.userID)
	+}
	+inline std::string* WalletLoginRequest::_internal_mutable_userid() {
	+
	+ return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* WalletLoginRequest::release_userid() {
	+ // @@protoc_insertion_point(field_release:identity.WalletLoginRequest.userID)
	+ return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void WalletLoginRequest::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:identity.WalletLoginRequest.userID)
	+}
	+
	+// string deviceID = 2;
	+inline void WalletLoginRequest::clear_deviceid() {
	+ deviceid_.ClearToEmpty();
	+}
	+inline const std::string& WalletLoginRequest::deviceid() const {
	+ // @@protoc_insertion_point(field_get:identity.WalletLoginRequest.deviceID)
	+ return _internal_deviceid();
	+}
	+inline void WalletLoginRequest::set_deviceid(const std::string& value) {
	+ _internal_set_deviceid(value);
	+ // @@protoc_insertion_point(field_set:identity.WalletLoginRequest.deviceID)
	+}
	+inline std::string* WalletLoginRequest::mutable_deviceid() {
	+ // @@protoc_insertion_point(field_mutable:identity.WalletLoginRequest.deviceID)
	+ return _internal_mutable_deviceid();
	+}
	+inline const std::string& WalletLoginRequest::_internal_deviceid() const {
	+ return deviceid_.Get();
	+}
	+inline void WalletLoginRequest::_internal_set_deviceid(const std::string& value) {
	+
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void WalletLoginRequest::set_deviceid(std::string&& value) {
	+
	+ deviceid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginRequest.deviceID)
	+}
	+inline void WalletLoginRequest::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:identity.WalletLoginRequest.deviceID)
	+}
	+inline void WalletLoginRequest::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:identity.WalletLoginRequest.deviceID)
	+}
	+inline std::string* WalletLoginRequest::_internal_mutable_deviceid() {
	+
	+ return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* WalletLoginRequest::release_deviceid() {
	+ // @@protoc_insertion_point(field_release:identity.WalletLoginRequest.deviceID)
	+ return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void WalletLoginRequest::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:identity.WalletLoginRequest.deviceID)
	+}
	+
	+// string siweMessage = 3;
	+inline void WalletLoginRequest::clear_siwemessage() {
	+ siwemessage_.ClearToEmpty();
	+}
	+inline const std::string& WalletLoginRequest::siwemessage() const {
	+ // @@protoc_insertion_point(field_get:identity.WalletLoginRequest.siweMessage)
	+ return _internal_siwemessage();
	+}
	+inline void WalletLoginRequest::set_siwemessage(const std::string& value) {
	+ _internal_set_siwemessage(value);
	+ // @@protoc_insertion_point(field_set:identity.WalletLoginRequest.siweMessage)
	+}
	+inline std::string* WalletLoginRequest::mutable_siwemessage() {
	+ // @@protoc_insertion_point(field_mutable:identity.WalletLoginRequest.siweMessage)
	+ return _internal_mutable_siwemessage();
	+}
	+inline const std::string& WalletLoginRequest::_internal_siwemessage() const {
	+ return siwemessage_.Get();
	+}
	+inline void WalletLoginRequest::_internal_set_siwemessage(const std::string& value) {
	+
	+ siwemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void WalletLoginRequest::set_siwemessage(std::string&& value) {
	+
	+ siwemessage_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginRequest.siweMessage)
	+}
	+inline void WalletLoginRequest::set_siwemessage(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ siwemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.WalletLoginRequest.siweMessage)
	+}
	+inline void WalletLoginRequest::set_siwemessage(const char* value,
	+ size_t size) {
	+
	+ siwemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.WalletLoginRequest.siweMessage)
	+}
	+inline std::string* WalletLoginRequest::_internal_mutable_siwemessage() {
	+
	+ return siwemessage_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* WalletLoginRequest::release_siwemessage() {
	+ // @@protoc_insertion_point(field_release:identity.WalletLoginRequest.siweMessage)
	+ return siwemessage_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void WalletLoginRequest::set_allocated_siwemessage(std::string* siwemessage) {
	+ if (siwemessage != nullptr) {
	+
	+ } else {
	+
	+ }
	+ siwemessage_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), siwemessage,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:identity.WalletLoginRequest.siweMessage)
	+}
	+
	+// bytes siweSignature = 4;
	+inline void WalletLoginRequest::clear_siwesignature() {
	+ siwesignature_.ClearToEmpty();
	+}
	+inline const std::string& WalletLoginRequest::siwesignature() const {
	+ // @@protoc_insertion_point(field_get:identity.WalletLoginRequest.siweSignature)
	+ return _internal_siwesignature();
	+}
	+inline void WalletLoginRequest::set_siwesignature(const std::string& value) {
	+ _internal_set_siwesignature(value);
	+ // @@protoc_insertion_point(field_set:identity.WalletLoginRequest.siweSignature)
	+}
	+inline std::string* WalletLoginRequest::mutable_siwesignature() {
	+ // @@protoc_insertion_point(field_mutable:identity.WalletLoginRequest.siweSignature)
	+ return _internal_mutable_siwesignature();
	+}
	+inline const std::string& WalletLoginRequest::_internal_siwesignature() const {
	+ return siwesignature_.Get();
	+}
	+inline void WalletLoginRequest::_internal_set_siwesignature(const std::string& value) {
	+
	+ siwesignature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void WalletLoginRequest::set_siwesignature(std::string&& value) {
	+
	+ siwesignature_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginRequest.siweSignature)
	+}
	+inline void WalletLoginRequest::set_siwesignature(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ siwesignature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.WalletLoginRequest.siweSignature)
	+}
	+inline void WalletLoginRequest::set_siwesignature(const void* value,
	+ size_t size) {
	+
	+ siwesignature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.WalletLoginRequest.siweSignature)
	+}
	+inline std::string* WalletLoginRequest::_internal_mutable_siwesignature() {
	+
	+ return siwesignature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* WalletLoginRequest::release_siwesignature() {
	+ // @@protoc_insertion_point(field_release:identity.WalletLoginRequest.siweSignature)
	+ return siwesignature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void WalletLoginRequest::set_allocated_siwesignature(std::string* siwesignature) {
	+ if (siwesignature != nullptr) {
	+
	+ } else {
	+
	+ }
	+ siwesignature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), siwesignature,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:identity.WalletLoginRequest.siweSignature)
	+}
	+
	+// -------------------------------------------------------------------
	+
	+// WalletLoginResponse
	+
	+// string accessToken = 1;
	+inline void WalletLoginResponse::clear_accesstoken() {
	+ accesstoken_.ClearToEmpty();
	+}
	+inline const std::string& WalletLoginResponse::accesstoken() const {
	+ // @@protoc_insertion_point(field_get:identity.WalletLoginResponse.accessToken)
	+ return _internal_accesstoken();
	+}
	+inline void WalletLoginResponse::set_accesstoken(const std::string& value) {
	+ _internal_set_accesstoken(value);
	+ // @@protoc_insertion_point(field_set:identity.WalletLoginResponse.accessToken)
	+}
	+inline std::string* WalletLoginResponse::mutable_accesstoken() {
	+ // @@protoc_insertion_point(field_mutable:identity.WalletLoginResponse.accessToken)
	+ return _internal_mutable_accesstoken();
	+}
	+inline const std::string& WalletLoginResponse::_internal_accesstoken() const {
	+ return accesstoken_.Get();
	+}
	+inline void WalletLoginResponse::_internal_set_accesstoken(const std::string& value) {
	+
	+ accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void WalletLoginResponse::set_accesstoken(std::string&& value) {
	+
	+ accesstoken_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginResponse.accessToken)
	+}
	+inline void WalletLoginResponse::set_accesstoken(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.WalletLoginResponse.accessToken)
	+}
	+inline void WalletLoginResponse::set_accesstoken(const char* value,
	+ size_t size) {
	+
	+ accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.WalletLoginResponse.accessToken)
	+}
	+inline std::string* WalletLoginResponse::_internal_mutable_accesstoken() {
	+
	+ return accesstoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* WalletLoginResponse::release_accesstoken() {
	+ // @@protoc_insertion_point(field_release:identity.WalletLoginResponse.accessToken)
	+ return accesstoken_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void WalletLoginResponse::set_allocated_accesstoken(std::string* accesstoken) {
	+ if (accesstoken != nullptr) {
	+
	+ } else {
	+
	+ }
	+ accesstoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), accesstoken,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:identity.WalletLoginResponse.accessToken)
	+}
	+
	+// -------------------------------------------------------------------
	+
	+// RegistrationRequest
	+
	+// .identity.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
	+inline bool RegistrationRequest::_internal_has_pakeregistrationrequestanduserid() const {
	+ return data_case() == kPakeRegistrationRequestAndUserID;
	+}
	+inline bool RegistrationRequest::has_pakeregistrationrequestanduserid() const {
	+ return _internal_has_pakeregistrationrequestanduserid();
	+}
	+inline void RegistrationRequest::set_has_pakeregistrationrequestanduserid() {
	+ _oneof_case_[0] = kPakeRegistrationRequestAndUserID;
	+}
	+inline void RegistrationRequest::clear_pakeregistrationrequestanduserid() {
	+ if (_internal_has_pakeregistrationrequestanduserid()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakeregistrationrequestanduserid_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::identity::PakeRegistrationRequestAndUserID* RegistrationRequest::release_pakeregistrationrequestanduserid() {
	+ // @@protoc_insertion_point(field_release:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
	+ if (_internal_has_pakeregistrationrequestanduserid()) {
	+ clear_has_data();
	+ ::identity::PakeRegistrationRequestAndUserID* temp = data_.pakeregistrationrequestanduserid_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.pakeregistrationrequestanduserid_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::identity::PakeRegistrationRequestAndUserID& RegistrationRequest::_internal_pakeregistrationrequestanduserid() const {
	+ return _internal_has_pakeregistrationrequestanduserid()
	+ ? *data_.pakeregistrationrequestanduserid_
	+ : reinterpret_cast< ::identity::PakeRegistrationRequestAndUserID&>(::identity::_PakeRegistrationRequestAndUserID_default_instance_);
	+}
	+inline const ::identity::PakeRegistrationRequestAndUserID& RegistrationRequest::pakeregistrationrequestanduserid() const {
	+ // @@protoc_insertion_point(field_get:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
	+ return _internal_pakeregistrationrequestanduserid();
	+}
	+inline ::identity::PakeRegistrationRequestAndUserID* RegistrationRequest::unsafe_arena_release_pakeregistrationrequestanduserid() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
	+ if (_internal_has_pakeregistrationrequestanduserid()) {
	+ clear_has_data();
	+ ::identity::PakeRegistrationRequestAndUserID* temp = data_.pakeregistrationrequestanduserid_;
	+ data_.pakeregistrationrequestanduserid_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void RegistrationRequest::unsafe_arena_set_allocated_pakeregistrationrequestanduserid(::identity::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid) {
	+ clear_data();
	+ if (pakeregistrationrequestanduserid) {
	+ set_has_pakeregistrationrequestanduserid();
	+ data_.pakeregistrationrequestanduserid_ = pakeregistrationrequestanduserid;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
	+}
	+inline ::identity::PakeRegistrationRequestAndUserID* RegistrationRequest::_internal_mutable_pakeregistrationrequestanduserid() {
	+ if (!_internal_has_pakeregistrationrequestanduserid()) {
	+ clear_data();
	+ set_has_pakeregistrationrequestanduserid();
	+ data_.pakeregistrationrequestanduserid_ = CreateMaybeMessage< ::identity::PakeRegistrationRequestAndUserID >(GetArena());
	+ }
	+ return data_.pakeregistrationrequestanduserid_;
	+}
	+inline ::identity::PakeRegistrationRequestAndUserID* RegistrationRequest::mutable_pakeregistrationrequestanduserid() {
	+ // @@protoc_insertion_point(field_mutable:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
	+ return _internal_mutable_pakeregistrationrequestanduserid();
	+}
	+
	+// .identity.PakeRegistrationUploadAndCredentialRequest pakeRegistrationUploadAndCredentialRequest = 2;
	+inline bool RegistrationRequest::_internal_has_pakeregistrationuploadandcredentialrequest() const {
	+ return data_case() == kPakeRegistrationUploadAndCredentialRequest;
	+}
	+inline bool RegistrationRequest::has_pakeregistrationuploadandcredentialrequest() const {
	+ return _internal_has_pakeregistrationuploadandcredentialrequest();
	+}
	+inline void RegistrationRequest::set_has_pakeregistrationuploadandcredentialrequest() {
	+ _oneof_case_[0] = kPakeRegistrationUploadAndCredentialRequest;
	+}
	+inline void RegistrationRequest::clear_pakeregistrationuploadandcredentialrequest() {
	+ if (_internal_has_pakeregistrationuploadandcredentialrequest()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakeregistrationuploadandcredentialrequest_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::identity::PakeRegistrationUploadAndCredentialRequest* RegistrationRequest::release_pakeregistrationuploadandcredentialrequest() {
	+ // @@protoc_insertion_point(field_release:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
	+ if (_internal_has_pakeregistrationuploadandcredentialrequest()) {
	+ clear_has_data();
	+ ::identity::PakeRegistrationUploadAndCredentialRequest* temp = data_.pakeregistrationuploadandcredentialrequest_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.pakeregistrationuploadandcredentialrequest_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::identity::PakeRegistrationUploadAndCredentialRequest& RegistrationRequest::_internal_pakeregistrationuploadandcredentialrequest() const {
	+ return _internal_has_pakeregistrationuploadandcredentialrequest()
	+ ? *data_.pakeregistrationuploadandcredentialrequest_
	+ : reinterpret_cast< ::identity::PakeRegistrationUploadAndCredentialRequest&>(::identity::_PakeRegistrationUploadAndCredentialRequest_default_instance_);
	+}
	+inline const ::identity::PakeRegistrationUploadAndCredentialRequest& RegistrationRequest::pakeregistrationuploadandcredentialrequest() const {
	+ // @@protoc_insertion_point(field_get:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
	+ return _internal_pakeregistrationuploadandcredentialrequest();
	+}
	+inline ::identity::PakeRegistrationUploadAndCredentialRequest* RegistrationRequest::unsafe_arena_release_pakeregistrationuploadandcredentialrequest() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
	+ if (_internal_has_pakeregistrationuploadandcredentialrequest()) {
	+ clear_has_data();
	+ ::identity::PakeRegistrationUploadAndCredentialRequest* temp = data_.pakeregistrationuploadandcredentialrequest_;
	+ data_.pakeregistrationuploadandcredentialrequest_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void RegistrationRequest::unsafe_arena_set_allocated_pakeregistrationuploadandcredentialrequest(::identity::PakeRegistrationUploadAndCredentialRequest* pakeregistrationuploadandcredentialrequest) {
	+ clear_data();
	+ if (pakeregistrationuploadandcredentialrequest) {
	+ set_has_pakeregistrationuploadandcredentialrequest();
	+ data_.pakeregistrationuploadandcredentialrequest_ = pakeregistrationuploadandcredentialrequest;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
	+}
	+inline ::identity::PakeRegistrationUploadAndCredentialRequest* RegistrationRequest::_internal_mutable_pakeregistrationuploadandcredentialrequest() {
	+ if (!_internal_has_pakeregistrationuploadandcredentialrequest()) {
	+ clear_data();
	+ set_has_pakeregistrationuploadandcredentialrequest();
	+ data_.pakeregistrationuploadandcredentialrequest_ = CreateMaybeMessage< ::identity::PakeRegistrationUploadAndCredentialRequest >(GetArena());
	+ }
	+ return data_.pakeregistrationuploadandcredentialrequest_;
	+}
	+inline ::identity::PakeRegistrationUploadAndCredentialRequest* RegistrationRequest::mutable_pakeregistrationuploadandcredentialrequest() {
	+ // @@protoc_insertion_point(field_mutable:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
	+ return _internal_mutable_pakeregistrationuploadandcredentialrequest();
	+}
	+
	+// bytes pakeCredentialFinalization = 3;
	+inline bool RegistrationRequest::_internal_has_pakecredentialfinalization() const {
	+ return data_case() == kPakeCredentialFinalization;
	+}
	+inline bool RegistrationRequest::has_pakecredentialfinalization() const {
	+ return _internal_has_pakecredentialfinalization();
	+}
	+inline void RegistrationRequest::set_has_pakecredentialfinalization() {
	+ _oneof_case_[0] = kPakeCredentialFinalization;
	+}
	+inline void RegistrationRequest::clear_pakecredentialfinalization() {
	+ if (_internal_has_pakecredentialfinalization()) {
	+ data_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_data();
	+ }
	+}
	+inline const std::string& RegistrationRequest::pakecredentialfinalization() const {
	+ // @@protoc_insertion_point(field_get:identity.RegistrationRequest.pakeCredentialFinalization)
	+ return _internal_pakecredentialfinalization();
	+}
	+inline void RegistrationRequest::set_pakecredentialfinalization(const std::string& value) {
	+ _internal_set_pakecredentialfinalization(value);
	+ // @@protoc_insertion_point(field_set:identity.RegistrationRequest.pakeCredentialFinalization)
	+}
	+inline std::string* RegistrationRequest::mutable_pakecredentialfinalization() {
	+ // @@protoc_insertion_point(field_mutable:identity.RegistrationRequest.pakeCredentialFinalization)
	+ return _internal_mutable_pakecredentialfinalization();
	+}
	+inline const std::string& RegistrationRequest::_internal_pakecredentialfinalization() const {
	+ if (_internal_has_pakecredentialfinalization()) {
	+ return data_.pakecredentialfinalization_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void RegistrationRequest::_internal_set_pakecredentialfinalization(const std::string& value) {
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_data();
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialfinalization_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void RegistrationRequest::set_pakecredentialfinalization(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:identity.RegistrationRequest.pakeCredentialFinalization)
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_data();
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialfinalization_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.RegistrationRequest.pakeCredentialFinalization)
	+}
	+inline void RegistrationRequest::set_pakecredentialfinalization(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_data();
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialfinalization_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.RegistrationRequest.pakeCredentialFinalization)
	+}
	+inline void RegistrationRequest::set_pakecredentialfinalization(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_data();
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakecredentialfinalization_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.RegistrationRequest.pakeCredentialFinalization)
	+}
	+inline std::string* RegistrationRequest::_internal_mutable_pakecredentialfinalization() {
	+ if (!_internal_has_pakecredentialfinalization()) {
	+ clear_data();
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return data_.pakecredentialfinalization_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* RegistrationRequest::release_pakecredentialfinalization() {
	+ // @@protoc_insertion_point(field_release:identity.RegistrationRequest.pakeCredentialFinalization)
	+ if (_internal_has_pakecredentialfinalization()) {
	+ clear_has_data();
	+ return data_.pakecredentialfinalization_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void RegistrationRequest::set_allocated_pakecredentialfinalization(std::string* pakecredentialfinalization) {
	+ if (has_data()) {
	+ clear_data();
	+ }
	+ if (pakecredentialfinalization != nullptr) {
	+ set_has_pakecredentialfinalization();
	+ data_.pakecredentialfinalization_.UnsafeSetDefault(pakecredentialfinalization);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakecredentialfinalization);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.RegistrationRequest.pakeCredentialFinalization)
	+}
	+
	+inline bool RegistrationRequest::has_data() const {
	+ return data_case() != DATA_NOT_SET;
	+}
	+inline void RegistrationRequest::clear_has_data() {
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+inline RegistrationRequest::DataCase RegistrationRequest::data_case() const {
	+ return RegistrationRequest::DataCase(_oneof_case_[0]);
	+}
	+// -------------------------------------------------------------------
	+
	+// RegistrationResponse
	+
	+// bytes pakeRegistrationResponse = 1;
	+inline bool RegistrationResponse::_internal_has_pakeregistrationresponse() const {
	+ return data_case() == kPakeRegistrationResponse;
	+}
	+inline bool RegistrationResponse::has_pakeregistrationresponse() const {
	+ return _internal_has_pakeregistrationresponse();
	+}
	+inline void RegistrationResponse::set_has_pakeregistrationresponse() {
	+ _oneof_case_[0] = kPakeRegistrationResponse;
	+}
	+inline void RegistrationResponse::clear_pakeregistrationresponse() {
	+ if (_internal_has_pakeregistrationresponse()) {
	+ data_.pakeregistrationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ clear_has_data();
	+ }
	+}
	+inline const std::string& RegistrationResponse::pakeregistrationresponse() const {
	+ // @@protoc_insertion_point(field_get:identity.RegistrationResponse.pakeRegistrationResponse)
	+ return _internal_pakeregistrationresponse();
	+}
	+inline void RegistrationResponse::set_pakeregistrationresponse(const std::string& value) {
	+ _internal_set_pakeregistrationresponse(value);
	+ // @@protoc_insertion_point(field_set:identity.RegistrationResponse.pakeRegistrationResponse)
	+}
	+inline std::string* RegistrationResponse::mutable_pakeregistrationresponse() {
	+ // @@protoc_insertion_point(field_mutable:identity.RegistrationResponse.pakeRegistrationResponse)
	+ return _internal_mutable_pakeregistrationresponse();
	+}
	+inline const std::string& RegistrationResponse::_internal_pakeregistrationresponse() const {
	+ if (_internal_has_pakeregistrationresponse()) {
	+ return data_.pakeregistrationresponse_.Get();
	+ }
	+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
	+}
	+inline void RegistrationResponse::_internal_set_pakeregistrationresponse(const std::string& value) {
	+ if (!_internal_has_pakeregistrationresponse()) {
	+ clear_data();
	+ set_has_pakeregistrationresponse();
	+ data_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakeregistrationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void RegistrationResponse::set_pakeregistrationresponse(std::string&& value) {
	+ // @@protoc_insertion_point(field_set:identity.RegistrationResponse.pakeRegistrationResponse)
	+ if (!_internal_has_pakeregistrationresponse()) {
	+ clear_data();
	+ set_has_pakeregistrationresponse();
	+ data_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakeregistrationresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.RegistrationResponse.pakeRegistrationResponse)
	+}
	+inline void RegistrationResponse::set_pakeregistrationresponse(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+ if (!_internal_has_pakeregistrationresponse()) {
	+ clear_data();
	+ set_has_pakeregistrationresponse();
	+ data_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakeregistrationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
	+ ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.RegistrationResponse.pakeRegistrationResponse)
	+}
	+inline void RegistrationResponse::set_pakeregistrationresponse(const void* value,
	+ size_t size) {
	+ if (!_internal_has_pakeregistrationresponse()) {
	+ clear_data();
	+ set_has_pakeregistrationresponse();
	+ data_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ data_.pakeregistrationresponse_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size),
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.RegistrationResponse.pakeRegistrationResponse)
	+}
	+inline std::string* RegistrationResponse::_internal_mutable_pakeregistrationresponse() {
	+ if (!_internal_has_pakeregistrationresponse()) {
	+ clear_data();
	+ set_has_pakeregistrationresponse();
	+ data_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ }
	+ return data_.pakeregistrationresponse_.Mutable(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* RegistrationResponse::release_pakeregistrationresponse() {
	+ // @@protoc_insertion_point(field_release:identity.RegistrationResponse.pakeRegistrationResponse)
	+ if (_internal_has_pakeregistrationresponse()) {
	+ clear_has_data();
	+ return data_.pakeregistrationresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void RegistrationResponse::set_allocated_pakeregistrationresponse(std::string* pakeregistrationresponse) {
	+ if (has_data()) {
	+ clear_data();
	+ }
	+ if (pakeregistrationresponse != nullptr) {
	+ set_has_pakeregistrationresponse();
	+ data_.pakeregistrationresponse_.UnsafeSetDefault(pakeregistrationresponse);
	+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
	+ if (arena != nullptr) {
	+ arena->Own(pakeregistrationresponse);
	+ }
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.RegistrationResponse.pakeRegistrationResponse)
	+}
	+
	+// .identity.PakeLoginResponse pakeLoginResponse = 2;
	+inline bool RegistrationResponse::_internal_has_pakeloginresponse() const {
	+ return data_case() == kPakeLoginResponse;
	+}
	+inline bool RegistrationResponse::has_pakeloginresponse() const {
	+ return _internal_has_pakeloginresponse();
	+}
	+inline void RegistrationResponse::set_has_pakeloginresponse() {
	+ _oneof_case_[0] = kPakeLoginResponse;
	+}
	+inline void RegistrationResponse::clear_pakeloginresponse() {
	+ if (_internal_has_pakeloginresponse()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakeloginresponse_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::identity::PakeLoginResponse* RegistrationResponse::release_pakeloginresponse() {
	+ // @@protoc_insertion_point(field_release:identity.RegistrationResponse.pakeLoginResponse)
	+ if (_internal_has_pakeloginresponse()) {
	+ clear_has_data();
	+ ::identity::PakeLoginResponse* temp = data_.pakeloginresponse_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.pakeloginresponse_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::identity::PakeLoginResponse& RegistrationResponse::_internal_pakeloginresponse() const {
	+ return _internal_has_pakeloginresponse()
	+ ? *data_.pakeloginresponse_
	+ : reinterpret_cast< ::identity::PakeLoginResponse&>(::identity::_PakeLoginResponse_default_instance_);
	+}
	+inline const ::identity::PakeLoginResponse& RegistrationResponse::pakeloginresponse() const {
	+ // @@protoc_insertion_point(field_get:identity.RegistrationResponse.pakeLoginResponse)
	+ return _internal_pakeloginresponse();
	+}
	+inline ::identity::PakeLoginResponse* RegistrationResponse::unsafe_arena_release_pakeloginresponse() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:identity.RegistrationResponse.pakeLoginResponse)
	+ if (_internal_has_pakeloginresponse()) {
	+ clear_has_data();
	+ ::identity::PakeLoginResponse* temp = data_.pakeloginresponse_;
	+ data_.pakeloginresponse_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void RegistrationResponse::unsafe_arena_set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse) {
	+ clear_data();
	+ if (pakeloginresponse) {
	+ set_has_pakeloginresponse();
	+ data_.pakeloginresponse_ = pakeloginresponse;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.RegistrationResponse.pakeLoginResponse)
	+}
	+inline ::identity::PakeLoginResponse* RegistrationResponse::_internal_mutable_pakeloginresponse() {
	+ if (!_internal_has_pakeloginresponse()) {
	+ clear_data();
	+ set_has_pakeloginresponse();
	+ data_.pakeloginresponse_ = CreateMaybeMessage< ::identity::PakeLoginResponse >(GetArena());
	+ }
	+ return data_.pakeloginresponse_;
	+}
	+inline ::identity::PakeLoginResponse* RegistrationResponse::mutable_pakeloginresponse() {
	+ // @@protoc_insertion_point(field_mutable:identity.RegistrationResponse.pakeLoginResponse)
	+ return _internal_mutable_pakeloginresponse();
	+}
	+
	+inline bool RegistrationResponse::has_data() const {
	+ return data_case() != DATA_NOT_SET;
	+}
	+inline void RegistrationResponse::clear_has_data() {
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+inline RegistrationResponse::DataCase RegistrationResponse::data_case() const {
	+ return RegistrationResponse::DataCase(_oneof_case_[0]);
	+}
	+// -------------------------------------------------------------------
	+
	+// LoginRequest
	+
	+// .identity.PakeLoginRequest pakeLoginRequest = 1;
	+inline bool LoginRequest::_internal_has_pakeloginrequest() const {
	+ return data_case() == kPakeLoginRequest;
	+}
	+inline bool LoginRequest::has_pakeloginrequest() const {
	+ return _internal_has_pakeloginrequest();
	+}
	+inline void LoginRequest::set_has_pakeloginrequest() {
	+ _oneof_case_[0] = kPakeLoginRequest;
	+}
	+inline void LoginRequest::clear_pakeloginrequest() {
	+ if (_internal_has_pakeloginrequest()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakeloginrequest_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::identity::PakeLoginRequest* LoginRequest::release_pakeloginrequest() {
	+ // @@protoc_insertion_point(field_release:identity.LoginRequest.pakeLoginRequest)
	+ if (_internal_has_pakeloginrequest()) {
	+ clear_has_data();
	+ ::identity::PakeLoginRequest* temp = data_.pakeloginrequest_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.pakeloginrequest_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::identity::PakeLoginRequest& LoginRequest::_internal_pakeloginrequest() const {
	+ return _internal_has_pakeloginrequest()
	+ ? *data_.pakeloginrequest_
	+ : reinterpret_cast< ::identity::PakeLoginRequest&>(::identity::_PakeLoginRequest_default_instance_);
	+}
	+inline const ::identity::PakeLoginRequest& LoginRequest::pakeloginrequest() const {
	+ // @@protoc_insertion_point(field_get:identity.LoginRequest.pakeLoginRequest)
	+ return _internal_pakeloginrequest();
	+}
	+inline ::identity::PakeLoginRequest* LoginRequest::unsafe_arena_release_pakeloginrequest() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:identity.LoginRequest.pakeLoginRequest)
	+ if (_internal_has_pakeloginrequest()) {
	+ clear_has_data();
	+ ::identity::PakeLoginRequest* temp = data_.pakeloginrequest_;
	+ data_.pakeloginrequest_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void LoginRequest::unsafe_arena_set_allocated_pakeloginrequest(::identity::PakeLoginRequest* pakeloginrequest) {
	+ clear_data();
	+ if (pakeloginrequest) {
	+ set_has_pakeloginrequest();
	+ data_.pakeloginrequest_ = pakeloginrequest;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.LoginRequest.pakeLoginRequest)
	+}
	+inline ::identity::PakeLoginRequest* LoginRequest::_internal_mutable_pakeloginrequest() {
	+ if (!_internal_has_pakeloginrequest()) {
	+ clear_data();
	+ set_has_pakeloginrequest();
	+ data_.pakeloginrequest_ = CreateMaybeMessage< ::identity::PakeLoginRequest >(GetArena());
	+ }
	+ return data_.pakeloginrequest_;
	+}
	+inline ::identity::PakeLoginRequest* LoginRequest::mutable_pakeloginrequest() {
	+ // @@protoc_insertion_point(field_mutable:identity.LoginRequest.pakeLoginRequest)
	+ return _internal_mutable_pakeloginrequest();
	+}
	+
	+// .identity.WalletLoginRequest walletLoginRequest = 2;
	+inline bool LoginRequest::_internal_has_walletloginrequest() const {
	+ return data_case() == kWalletLoginRequest;
	+}
	+inline bool LoginRequest::has_walletloginrequest() const {
	+ return _internal_has_walletloginrequest();
	+}
	+inline void LoginRequest::set_has_walletloginrequest() {
	+ _oneof_case_[0] = kWalletLoginRequest;
	+}
	+inline void LoginRequest::clear_walletloginrequest() {
	+ if (_internal_has_walletloginrequest()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.walletloginrequest_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::identity::WalletLoginRequest* LoginRequest::release_walletloginrequest() {
	+ // @@protoc_insertion_point(field_release:identity.LoginRequest.walletLoginRequest)
	+ if (_internal_has_walletloginrequest()) {
	+ clear_has_data();
	+ ::identity::WalletLoginRequest* temp = data_.walletloginrequest_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.walletloginrequest_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::identity::WalletLoginRequest& LoginRequest::_internal_walletloginrequest() const {
	+ return _internal_has_walletloginrequest()
	+ ? *data_.walletloginrequest_
	+ : reinterpret_cast< ::identity::WalletLoginRequest&>(::identity::_WalletLoginRequest_default_instance_);
	+}
	+inline const ::identity::WalletLoginRequest& LoginRequest::walletloginrequest() const {
	+ // @@protoc_insertion_point(field_get:identity.LoginRequest.walletLoginRequest)
	+ return _internal_walletloginrequest();
	+}
	+inline ::identity::WalletLoginRequest* LoginRequest::unsafe_arena_release_walletloginrequest() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:identity.LoginRequest.walletLoginRequest)
	+ if (_internal_has_walletloginrequest()) {
	+ clear_has_data();
	+ ::identity::WalletLoginRequest* temp = data_.walletloginrequest_;
	+ data_.walletloginrequest_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void LoginRequest::unsafe_arena_set_allocated_walletloginrequest(::identity::WalletLoginRequest* walletloginrequest) {
	+ clear_data();
	+ if (walletloginrequest) {
	+ set_has_walletloginrequest();
	+ data_.walletloginrequest_ = walletloginrequest;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.LoginRequest.walletLoginRequest)
	+}
	+inline ::identity::WalletLoginRequest* LoginRequest::_internal_mutable_walletloginrequest() {
	+ if (!_internal_has_walletloginrequest()) {
	+ clear_data();
	+ set_has_walletloginrequest();
	+ data_.walletloginrequest_ = CreateMaybeMessage< ::identity::WalletLoginRequest >(GetArena());
	+ }
	+ return data_.walletloginrequest_;
	+}
	+inline ::identity::WalletLoginRequest* LoginRequest::mutable_walletloginrequest() {
	+ // @@protoc_insertion_point(field_mutable:identity.LoginRequest.walletLoginRequest)
	+ return _internal_mutable_walletloginrequest();
	+}
	+
	+inline bool LoginRequest::has_data() const {
	+ return data_case() != DATA_NOT_SET;
	+}
	+inline void LoginRequest::clear_has_data() {
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+inline LoginRequest::DataCase LoginRequest::data_case() const {
	+ return LoginRequest::DataCase(_oneof_case_[0]);
	+}
	+// -------------------------------------------------------------------
	+
	+// LoginResponse
	+
	+// .identity.PakeLoginResponse pakeLoginResponse = 1;
	+inline bool LoginResponse::_internal_has_pakeloginresponse() const {
	+ return data_case() == kPakeLoginResponse;
	+}
	+inline bool LoginResponse::has_pakeloginresponse() const {
	+ return _internal_has_pakeloginresponse();
	+}
	+inline void LoginResponse::set_has_pakeloginresponse() {
	+ _oneof_case_[0] = kPakeLoginResponse;
	+}
	+inline void LoginResponse::clear_pakeloginresponse() {
	+ if (_internal_has_pakeloginresponse()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakeloginresponse_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::identity::PakeLoginResponse* LoginResponse::release_pakeloginresponse() {
	+ // @@protoc_insertion_point(field_release:identity.LoginResponse.pakeLoginResponse)
	+ if (_internal_has_pakeloginresponse()) {
	+ clear_has_data();
	+ ::identity::PakeLoginResponse* temp = data_.pakeloginresponse_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.pakeloginresponse_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::identity::PakeLoginResponse& LoginResponse::_internal_pakeloginresponse() const {
	+ return _internal_has_pakeloginresponse()
	+ ? *data_.pakeloginresponse_
	+ : reinterpret_cast< ::identity::PakeLoginResponse&>(::identity::_PakeLoginResponse_default_instance_);
	+}
	+inline const ::identity::PakeLoginResponse& LoginResponse::pakeloginresponse() const {
	+ // @@protoc_insertion_point(field_get:identity.LoginResponse.pakeLoginResponse)
	+ return _internal_pakeloginresponse();
	+}
	+inline ::identity::PakeLoginResponse* LoginResponse::unsafe_arena_release_pakeloginresponse() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:identity.LoginResponse.pakeLoginResponse)
	+ if (_internal_has_pakeloginresponse()) {
	+ clear_has_data();
	+ ::identity::PakeLoginResponse* temp = data_.pakeloginresponse_;
	+ data_.pakeloginresponse_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void LoginResponse::unsafe_arena_set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse) {
	+ clear_data();
	+ if (pakeloginresponse) {
	+ set_has_pakeloginresponse();
	+ data_.pakeloginresponse_ = pakeloginresponse;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.LoginResponse.pakeLoginResponse)
	+}
	+inline ::identity::PakeLoginResponse* LoginResponse::_internal_mutable_pakeloginresponse() {
	+ if (!_internal_has_pakeloginresponse()) {
	+ clear_data();
	+ set_has_pakeloginresponse();
	+ data_.pakeloginresponse_ = CreateMaybeMessage< ::identity::PakeLoginResponse >(GetArena());
	+ }
	+ return data_.pakeloginresponse_;
	+}
	+inline ::identity::PakeLoginResponse* LoginResponse::mutable_pakeloginresponse() {
	+ // @@protoc_insertion_point(field_mutable:identity.LoginResponse.pakeLoginResponse)
	+ return _internal_mutable_pakeloginresponse();
	+}
	+
	+// .identity.WalletLoginResponse walletLoginResponse = 2;
	+inline bool LoginResponse::_internal_has_walletloginresponse() const {
	+ return data_case() == kWalletLoginResponse;
	+}
	+inline bool LoginResponse::has_walletloginresponse() const {
	+ return _internal_has_walletloginresponse();
	+}
	+inline void LoginResponse::set_has_walletloginresponse() {
	+ _oneof_case_[0] = kWalletLoginResponse;
	+}
	+inline void LoginResponse::clear_walletloginresponse() {
	+ if (_internal_has_walletloginresponse()) {
	+ if (GetArena() == nullptr) {
	+ delete data_.walletloginresponse_;
	+ }
	+ clear_has_data();
	+ }
	+}
	+inline ::identity::WalletLoginResponse* LoginResponse::release_walletloginresponse() {
	+ // @@protoc_insertion_point(field_release:identity.LoginResponse.walletLoginResponse)
	+ if (_internal_has_walletloginresponse()) {
	+ clear_has_data();
	+ ::identity::WalletLoginResponse* temp = data_.walletloginresponse_;
	+ if (GetArena() != nullptr) {
	+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
	+ }
	+ data_.walletloginresponse_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline const ::identity::WalletLoginResponse& LoginResponse::_internal_walletloginresponse() const {
	+ return _internal_has_walletloginresponse()
	+ ? *data_.walletloginresponse_
	+ : reinterpret_cast< ::identity::WalletLoginResponse&>(::identity::_WalletLoginResponse_default_instance_);
	+}
	+inline const ::identity::WalletLoginResponse& LoginResponse::walletloginresponse() const {
	+ // @@protoc_insertion_point(field_get:identity.LoginResponse.walletLoginResponse)
	+ return _internal_walletloginresponse();
	+}
	+inline ::identity::WalletLoginResponse* LoginResponse::unsafe_arena_release_walletloginresponse() {
	+ // @@protoc_insertion_point(field_unsafe_arena_release:identity.LoginResponse.walletLoginResponse)
	+ if (_internal_has_walletloginresponse()) {
	+ clear_has_data();
	+ ::identity::WalletLoginResponse* temp = data_.walletloginresponse_;
	+ data_.walletloginresponse_ = nullptr;
	+ return temp;
	+ } else {
	+ return nullptr;
	+ }
	+}
	+inline void LoginResponse::unsafe_arena_set_allocated_walletloginresponse(::identity::WalletLoginResponse* walletloginresponse) {
	+ clear_data();
	+ if (walletloginresponse) {
	+ set_has_walletloginresponse();
	+ data_.walletloginresponse_ = walletloginresponse;
	+ }
	+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.LoginResponse.walletLoginResponse)
	+}
	+inline ::identity::WalletLoginResponse* LoginResponse::_internal_mutable_walletloginresponse() {
	+ if (!_internal_has_walletloginresponse()) {
	+ clear_data();
	+ set_has_walletloginresponse();
	+ data_.walletloginresponse_ = CreateMaybeMessage< ::identity::WalletLoginResponse >(GetArena());
	+ }
	+ return data_.walletloginresponse_;
	+}
	+inline ::identity::WalletLoginResponse* LoginResponse::mutable_walletloginresponse() {
	+ // @@protoc_insertion_point(field_mutable:identity.LoginResponse.walletLoginResponse)
	+ return _internal_mutable_walletloginresponse();
	+}
	+
	+inline bool LoginResponse::has_data() const {
	+ return data_case() != DATA_NOT_SET;
	+}
	+inline void LoginResponse::clear_has_data() {
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+inline LoginResponse::DataCase LoginResponse::data_case() const {
	+ return LoginResponse::DataCase(_oneof_case_[0]);
	+}
	+// -------------------------------------------------------------------
	+
	+// VerifyUserTokenRequest
	+
	+// string userID = 1;
	+inline void VerifyUserTokenRequest::clear_userid() {
	+ userid_.ClearToEmpty();
	+}
	+inline const std::string& VerifyUserTokenRequest::userid() const {
	+ // @@protoc_insertion_point(field_get:identity.VerifyUserTokenRequest.userID)
	+ return _internal_userid();
	+}
	+inline void VerifyUserTokenRequest::set_userid(const std::string& value) {
	+ _internal_set_userid(value);
	+ // @@protoc_insertion_point(field_set:identity.VerifyUserTokenRequest.userID)
	+}
	+inline std::string* VerifyUserTokenRequest::mutable_userid() {
	+ // @@protoc_insertion_point(field_mutable:identity.VerifyUserTokenRequest.userID)
	+ return _internal_mutable_userid();
	+}
	+inline const std::string& VerifyUserTokenRequest::_internal_userid() const {
	+ return userid_.Get();
	+}
	+inline void VerifyUserTokenRequest::_internal_set_userid(const std::string& value) {
	+
	+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void VerifyUserTokenRequest::set_userid(std::string&& value) {
	+
	+ userid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.VerifyUserTokenRequest.userID)
	+}
	+inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.userID)
	+}
	+inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.userID)
	+}
	+inline std::string* VerifyUserTokenRequest::_internal_mutable_userid() {
	+
	+ return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* VerifyUserTokenRequest::release_userid() {
	+ // @@protoc_insertion_point(field_release:identity.VerifyUserTokenRequest.userID)
	+ return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.userID)
	+}
	+
	+// string deviceID = 2;
	+inline void VerifyUserTokenRequest::clear_deviceid() {
	+ deviceid_.ClearToEmpty();
	+}
	+inline const std::string& VerifyUserTokenRequest::deviceid() const {
	+ // @@protoc_insertion_point(field_get:identity.VerifyUserTokenRequest.deviceID)
	+ return _internal_deviceid();
	+}
	+inline void VerifyUserTokenRequest::set_deviceid(const std::string& value) {
	+ _internal_set_deviceid(value);
	+ // @@protoc_insertion_point(field_set:identity.VerifyUserTokenRequest.deviceID)
	+}
	+inline std::string* VerifyUserTokenRequest::mutable_deviceid() {
	+ // @@protoc_insertion_point(field_mutable:identity.VerifyUserTokenRequest.deviceID)
	+ return _internal_mutable_deviceid();
	+}
	+inline const std::string& VerifyUserTokenRequest::_internal_deviceid() const {
	+ return deviceid_.Get();
	+}
	+inline void VerifyUserTokenRequest::_internal_set_deviceid(const std::string& value) {
	+
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void VerifyUserTokenRequest::set_deviceid(std::string&& value) {
	+
	+ deviceid_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.VerifyUserTokenRequest.deviceID)
	+}
	+inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.deviceID)
	+}
	+inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.deviceID)
	+}
	+inline std::string* VerifyUserTokenRequest::_internal_mutable_deviceid() {
	+
	+ return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* VerifyUserTokenRequest::release_deviceid() {
	+ // @@protoc_insertion_point(field_release:identity.VerifyUserTokenRequest.deviceID)
	+ return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.deviceID)
	+}
	+
	+// string accessToken = 3;
	+inline void VerifyUserTokenRequest::clear_accesstoken() {
	+ accesstoken_.ClearToEmpty();
	+}
	+inline const std::string& VerifyUserTokenRequest::accesstoken() const {
	+ // @@protoc_insertion_point(field_get:identity.VerifyUserTokenRequest.accessToken)
	+ return _internal_accesstoken();
	+}
	+inline void VerifyUserTokenRequest::set_accesstoken(const std::string& value) {
	+ _internal_set_accesstoken(value);
	+ // @@protoc_insertion_point(field_set:identity.VerifyUserTokenRequest.accessToken)
	+}
	+inline std::string* VerifyUserTokenRequest::mutable_accesstoken() {
	+ // @@protoc_insertion_point(field_mutable:identity.VerifyUserTokenRequest.accessToken)
	+ return _internal_mutable_accesstoken();
	+}
	+inline const std::string& VerifyUserTokenRequest::_internal_accesstoken() const {
	+ return accesstoken_.Get();
	+}
	+inline void VerifyUserTokenRequest::_internal_set_accesstoken(const std::string& value) {
	+
	+ accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
	+}
	+inline void VerifyUserTokenRequest::set_accesstoken(std::string&& value) {
	+
	+ accesstoken_.Set(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
	+ // @@protoc_insertion_point(field_set_rvalue:identity.VerifyUserTokenRequest.accessToken)
	+}
	+inline void VerifyUserTokenRequest::set_accesstoken(const char* value) {
	+ GOOGLE_DCHECK(value != nullptr);
	+
	+ accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
	+ // @@protoc_insertion_point(field_set_char:identity.VerifyUserTokenRequest.accessToken)
	+}
	+inline void VerifyUserTokenRequest::set_accesstoken(const char* value,
	+ size_t size) {
	+
	+ accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
	+ reinterpret_cast<const char*>(value), size), GetArena());
	+ // @@protoc_insertion_point(field_set_pointer:identity.VerifyUserTokenRequest.accessToken)
	+}
	+inline std::string* VerifyUserTokenRequest::_internal_mutable_accesstoken() {
	+
	+ return accesstoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+}
	+inline std::string* VerifyUserTokenRequest::release_accesstoken() {
	+ // @@protoc_insertion_point(field_release:identity.VerifyUserTokenRequest.accessToken)
	+ return accesstoken_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+inline void VerifyUserTokenRequest::set_allocated_accesstoken(std::string* accesstoken) {
	+ if (accesstoken != nullptr) {
	+
	+ } else {
	+
	+ }
	+ accesstoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), accesstoken,
	+ GetArena());
	+ // @@protoc_insertion_point(field_set_allocated:identity.VerifyUserTokenRequest.accessToken)
	+}
	+
	+// -------------------------------------------------------------------
	+
	+// VerifyUserTokenResponse
	+
	+// bool tokenValid = 1;
	+inline void VerifyUserTokenResponse::clear_tokenvalid() {
	+ tokenvalid_ = false;
	+}
	+inline bool VerifyUserTokenResponse::_internal_tokenvalid() const {
	+ return tokenvalid_;
	+}
	+inline bool VerifyUserTokenResponse::tokenvalid() const {
	+ // @@protoc_insertion_point(field_get:identity.VerifyUserTokenResponse.tokenValid)
	+ return _internal_tokenvalid();
	+}
	+inline void VerifyUserTokenResponse::_internal_set_tokenvalid(bool value) {
	+
	+ tokenvalid_ = value;
	+}
	+inline void VerifyUserTokenResponse::set_tokenvalid(bool value) {
	+ _internal_set_tokenvalid(value);
	+ // @@protoc_insertion_point(field_set:identity.VerifyUserTokenResponse.tokenValid)
	+}
	+
	+#ifdef __GNUC__
	+ #pragma GCC diagnostic pop
	+#endif // __GNUC__
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+// -------------------------------------------------------------------
	+
	+
	+// @@protoc_insertion_point(namespace_scope)
	+
	+} // namespace identity
	+
	+// @@protoc_insertion_point(global_scope)
	+
	+#include <google/protobuf/port_undef.inc>
	+#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_identity_2eproto
	diff --git a/native/cpp/CommonCpp/grpc/_generated/identity.pb.cc b/native/cpp/CommonCpp/grpc/_generated/identity.pb.cc
	new file mode 100644
	--- /dev/null
	+++ b/native/cpp/CommonCpp/grpc/_generated/identity.pb.cc
	@@ -0,0 +1,3971 @@
	+// @generated by the protocol buffer compiler. DO NOT EDIT!
	+// source: identity.proto
	+
	+#include "identity.pb.h"
	+
	+#include <algorithm>
	+
	+#include <google/protobuf/io/coded_stream.h>
	+#include <google/protobuf/extension_set.h>
	+#include <google/protobuf/wire_format_lite.h>
	+#include <google/protobuf/descriptor.h>
	+#include <google/protobuf/generated_message_reflection.h>
	+#include <google/protobuf/reflection_ops.h>
	+#include <google/protobuf/wire_format.h>
	+// @@protoc_insertion_point(includes)
	+#include <google/protobuf/port_def.inc>
	+
	+PROTOBUF_PRAGMA_INIT_SEG
	+namespace identity {
	+constexpr PakeRegistrationRequestAndUserID::PakeRegistrationRequestAndUserID(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , pakeregistrationrequest_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	+struct PakeRegistrationRequestAndUserIDDefaultTypeInternal {
	+ constexpr PakeRegistrationRequestAndUserIDDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~PakeRegistrationRequestAndUserIDDefaultTypeInternal() {}
	+ union {
	+ PakeRegistrationRequestAndUserID _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeRegistrationRequestAndUserIDDefaultTypeInternal _PakeRegistrationRequestAndUserID_default_instance_;
	+constexpr PakeCredentialRequestAndUserID::PakeCredentialRequestAndUserID(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , pakecredentialrequest_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	+struct PakeCredentialRequestAndUserIDDefaultTypeInternal {
	+ constexpr PakeCredentialRequestAndUserIDDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~PakeCredentialRequestAndUserIDDefaultTypeInternal() {}
	+ union {
	+ PakeCredentialRequestAndUserID _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeCredentialRequestAndUserIDDefaultTypeInternal _PakeCredentialRequestAndUserID_default_instance_;
	+constexpr PakeLoginRequest::PakeLoginRequest(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : _oneof_case_{}{}
	+struct PakeLoginRequestDefaultTypeInternal {
	+ constexpr PakeLoginRequestDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~PakeLoginRequestDefaultTypeInternal() {}
	+ union {
	+ PakeLoginRequest _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeLoginRequestDefaultTypeInternal _PakeLoginRequest_default_instance_;
	+constexpr PakeLoginResponse::PakeLoginResponse(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : _oneof_case_{}{}
	+struct PakeLoginResponseDefaultTypeInternal {
	+ constexpr PakeLoginResponseDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~PakeLoginResponseDefaultTypeInternal() {}
	+ union {
	+ PakeLoginResponse _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeLoginResponseDefaultTypeInternal _PakeLoginResponse_default_instance_;
	+constexpr PakeRegistrationUploadAndCredentialRequest::PakeRegistrationUploadAndCredentialRequest(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : pakeregistrationupload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , pakecredentialrequest_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	+struct PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal {
	+ constexpr PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal() {}
	+ union {
	+ PakeRegistrationUploadAndCredentialRequest _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal _PakeRegistrationUploadAndCredentialRequest_default_instance_;
	+constexpr WalletLoginRequest::WalletLoginRequest(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , siwemessage_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , siwesignature_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	+struct WalletLoginRequestDefaultTypeInternal {
	+ constexpr WalletLoginRequestDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~WalletLoginRequestDefaultTypeInternal() {}
	+ union {
	+ WalletLoginRequest _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WalletLoginRequestDefaultTypeInternal _WalletLoginRequest_default_instance_;
	+constexpr WalletLoginResponse::WalletLoginResponse(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : accesstoken_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	+struct WalletLoginResponseDefaultTypeInternal {
	+ constexpr WalletLoginResponseDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~WalletLoginResponseDefaultTypeInternal() {}
	+ union {
	+ WalletLoginResponse _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WalletLoginResponseDefaultTypeInternal _WalletLoginResponse_default_instance_;
	+constexpr RegistrationRequest::RegistrationRequest(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : _oneof_case_{}{}
	+struct RegistrationRequestDefaultTypeInternal {
	+ constexpr RegistrationRequestDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~RegistrationRequestDefaultTypeInternal() {}
	+ union {
	+ RegistrationRequest _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RegistrationRequestDefaultTypeInternal _RegistrationRequest_default_instance_;
	+constexpr RegistrationResponse::RegistrationResponse(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : _oneof_case_{}{}
	+struct RegistrationResponseDefaultTypeInternal {
	+ constexpr RegistrationResponseDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~RegistrationResponseDefaultTypeInternal() {}
	+ union {
	+ RegistrationResponse _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RegistrationResponseDefaultTypeInternal _RegistrationResponse_default_instance_;
	+constexpr LoginRequest::LoginRequest(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : _oneof_case_{}{}
	+struct LoginRequestDefaultTypeInternal {
	+ constexpr LoginRequestDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~LoginRequestDefaultTypeInternal() {}
	+ union {
	+ LoginRequest _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginRequestDefaultTypeInternal _LoginRequest_default_instance_;
	+constexpr LoginResponse::LoginResponse(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : _oneof_case_{}{}
	+struct LoginResponseDefaultTypeInternal {
	+ constexpr LoginResponseDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~LoginResponseDefaultTypeInternal() {}
	+ union {
	+ LoginResponse _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginResponseDefaultTypeInternal _LoginResponse_default_instance_;
	+constexpr VerifyUserTokenRequest::VerifyUserTokenRequest(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
	+ , accesstoken_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
	+struct VerifyUserTokenRequestDefaultTypeInternal {
	+ constexpr VerifyUserTokenRequestDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~VerifyUserTokenRequestDefaultTypeInternal() {}
	+ union {
	+ VerifyUserTokenRequest _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT VerifyUserTokenRequestDefaultTypeInternal _VerifyUserTokenRequest_default_instance_;
	+constexpr VerifyUserTokenResponse::VerifyUserTokenResponse(
	+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	+ : tokenvalid_(false){}
	+struct VerifyUserTokenResponseDefaultTypeInternal {
	+ constexpr VerifyUserTokenResponseDefaultTypeInternal()
	+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	+ ~VerifyUserTokenResponseDefaultTypeInternal() {}
	+ union {
	+ VerifyUserTokenResponse _instance;
	+ };
	+};
	+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT VerifyUserTokenResponseDefaultTypeInternal _VerifyUserTokenResponse_default_instance_;
	+} // namespace identity
	+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_identity_2eproto[13];
	+static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_identity_2eproto = nullptr;
	+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_identity_2eproto = nullptr;
	+
	+const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_identity_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationRequestAndUserID, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ ~0u, // no _oneof_case_
	+ ~0u, // no _weak_field_map_
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationRequestAndUserID, userid_),
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationRequestAndUserID, deviceid_),
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationRequestAndUserID, pakeregistrationrequest_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeCredentialRequestAndUserID, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ ~0u, // no _oneof_case_
	+ ~0u, // no _weak_field_map_
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeCredentialRequestAndUserID, userid_),
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeCredentialRequestAndUserID, deviceid_),
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeCredentialRequestAndUserID, pakecredentialrequest_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeLoginRequest, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeLoginRequest, _oneof_case_[0]),
	+ ~0u, // no _weak_field_map_
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeLoginRequest, data_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeLoginResponse, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeLoginResponse, _oneof_case_[0]),
	+ ~0u, // no _weak_field_map_
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeLoginResponse, data_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationUploadAndCredentialRequest, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ ~0u, // no _oneof_case_
	+ ~0u, // no _weak_field_map_
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationUploadAndCredentialRequest, pakeregistrationupload_),
	+ PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationUploadAndCredentialRequest, pakecredentialrequest_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ ~0u, // no _oneof_case_
	+ ~0u, // no _weak_field_map_
	+ PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, userid_),
	+ PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, deviceid_),
	+ PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, siwemessage_),
	+ PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, siwesignature_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::WalletLoginResponse, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ ~0u, // no _oneof_case_
	+ ~0u, // no _weak_field_map_
	+ PROTOBUF_FIELD_OFFSET(::identity::WalletLoginResponse, accesstoken_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::RegistrationRequest, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::identity::RegistrationRequest, _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(::identity::RegistrationRequest, data_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::RegistrationResponse, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::identity::RegistrationResponse, _oneof_case_[0]),
	+ ~0u, // no _weak_field_map_
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::identity::RegistrationResponse, data_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::LoginRequest, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::identity::LoginRequest, _oneof_case_[0]),
	+ ~0u, // no _weak_field_map_
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::identity::LoginRequest, data_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::LoginResponse, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ PROTOBUF_FIELD_OFFSET(::identity::LoginResponse, _oneof_case_[0]),
	+ ~0u, // no _weak_field_map_
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
	+ PROTOBUF_FIELD_OFFSET(::identity::LoginResponse, data_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenRequest, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ ~0u, // no _oneof_case_
	+ ~0u, // no _weak_field_map_
	+ PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenRequest, userid_),
	+ PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenRequest, deviceid_),
	+ PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenRequest, accesstoken_),
	+ ~0u, // no _has_bits_
	+ PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenResponse, _internal_metadata_),
	+ ~0u, // no _extensions_
	+ ~0u, // no _oneof_case_
	+ ~0u, // no _weak_field_map_
	+ PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenResponse, tokenvalid_),
	+};
	+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
	+ { 0, -1, sizeof(::identity::PakeRegistrationRequestAndUserID)},
	+ { 8, -1, sizeof(::identity::PakeCredentialRequestAndUserID)},
	+ { 16, -1, sizeof(::identity::PakeLoginRequest)},
	+ { 24, -1, sizeof(::identity::PakeLoginResponse)},
	+ { 32, -1, sizeof(::identity::PakeRegistrationUploadAndCredentialRequest)},
	+ { 39, -1, sizeof(::identity::WalletLoginRequest)},
	+ { 48, -1, sizeof(::identity::WalletLoginResponse)},
	+ { 54, -1, sizeof(::identity::RegistrationRequest)},
	+ { 63, -1, sizeof(::identity::RegistrationResponse)},
	+ { 71, -1, sizeof(::identity::LoginRequest)},
	+ { 79, -1, sizeof(::identity::LoginResponse)},
	+ { 87, -1, sizeof(::identity::VerifyUserTokenRequest)},
	+ { 95, -1, sizeof(::identity::VerifyUserTokenResponse)},
	+};
	+
	+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_PakeRegistrationRequestAndUserID_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_PakeCredentialRequestAndUserID_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_PakeLoginRequest_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_PakeLoginResponse_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_PakeRegistrationUploadAndCredentialRequest_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_WalletLoginRequest_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_WalletLoginResponse_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_RegistrationRequest_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_RegistrationResponse_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_LoginRequest_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_LoginResponse_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_VerifyUserTokenRequest_default_instance_),
	+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_VerifyUserTokenResponse_default_instance_),
	+};
	+
	+const char descriptor_table_protodef_identity_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
	+ "\n\016identity.proto\022\010identity\"e\n PakeRegist"
	+ "rationRequestAndUserID\022\016\n\006userID\030\001 \001(\t\022\020"
	+ "\n\010deviceID\030\002 \001(\t\022\037\n\027pakeRegistrationRequ"
	+ "est\030\003 \001(\014\"a\n\036PakeCredentialRequestAndUse"
	+ "rID\022\016\n\006userID\030\001 \001(\t\022\020\n\010deviceID\030\002 \001(\t\022\035\n"
	+ "\025pakeCredentialRequest\030\003 \001(\014\"\224\001\n\020PakeLog"
	+ "inRequest\022R\n\036pakeCredentialRequestAndUse"
	+ "rID\030\001 \001(\0132(.identity.PakeCredentialReque"
	+ "stAndUserIDH\000\022$\n\032pakeCredentialFinalizat"
	+ "ion\030\002 \001(\014H\000B\006\n\004data\"T\n\021PakeLoginResponse"
	+ "\022 \n\026pakeCredentialResponse\030\001 \001(\014H\000\022\025\n\013ac"
	+ "cessToken\030\002 \001(\tH\000B\006\n\004data\"k\n*PakeRegistr"
	+ "ationUploadAndCredentialRequest\022\036\n\026pakeR"
	+ "egistrationUpload\030\001 \001(\014\022\035\n\025pakeCredentia"
	+ "lRequest\030\002 \001(\014\"b\n\022WalletLoginRequest\022\016\n\006"
	+ "userID\030\001 \001(\t\022\020\n\010deviceID\030\002 \001(\t\022\023\n\013siweMe"
	+ "ssage\030\003 \001(\t\022\025\n\rsiweSignature\030\004 \001(\014\"*\n\023Wa"
	+ "lletLoginResponse\022\023\n\013accessToken\030\001 \001(\t\"\207"
	+ "\002\n\023RegistrationRequest\022V\n pakeRegistrati"
	+ "onRequestAndUserID\030\001 \001(\0132*.identity.Pake"
	+ "RegistrationRequestAndUserIDH\000\022j\n*pakeRe"
	+ "gistrationUploadAndCredentialRequest\030\002 \001"
	+ "(\01324.identity.PakeRegistrationUploadAndC"
	+ "redentialRequestH\000\022$\n\032pakeCredentialFina"
	+ "lization\030\003 \001(\014H\000B\006\n\004data\"\|\n\024Registration"
	+ "Response\022\"\n\030pakeRegistrationResponse\030\001 \001"
	+ "(\014H\000\0228\n\021pakeLoginResponse\030\002 \001(\0132\033.identi"
	+ "ty.PakeLoginResponseH\000B\006\n\004data\"\212\001\n\014Login"
	+ "Request\0226\n\020pakeLoginRequest\030\001 \001(\0132\032.iden"
	+ "tity.PakeLoginRequestH\000\022:\n\022walletLoginRe"
	+ "quest\030\002 \001(\0132\034.identity.WalletLoginReques"
	+ "tH\000B\006\n\004data\"\217\001\n\rLoginResponse\0228\n\021pakeLog"
	+ "inResponse\030\001 \001(\0132\033.identity.PakeLoginRes"
	+ "ponseH\000\022<\n\023walletLoginResponse\030\002 \001(\0132\035.i"
	+ "dentity.WalletLoginResponseH\000B\006\n\004data\"O\n"
	+ "\026VerifyUserTokenRequest\022\016\n\006userID\030\001 \001(\t\022"
	+ "\020\n\010deviceID\030\002 \001(\t\022\023\n\013accessToken\030\003 \001(\t\"-"
	+ "\n\027VerifyUserTokenResponse\022\022\n\ntokenValid\030"
	+ "\001 \001(\0102\204\002\n\017IdentityService\022S\n\014RegisterUse"
	+ "r\022\035.identity.RegistrationRequest\032\036.ident"
	+ "ity.RegistrationResponse\"\000(\0010\001\022B\n\tLoginU"
	+ "ser\022\026.identity.LoginRequest\032\027.identity.L"
	+ "oginResponse\"\000(\0010\001\022X\n\017VerifyUserToken\022 ."
	+ "identity.VerifyUserTokenRequest\032!.identi"
	+ "ty.VerifyUserTokenResponse\"\000b\006proto3"
	+ ;
	+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_identity_2eproto_once;
	+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_identity_2eproto = {
	+ false, false, 1796, descriptor_table_protodef_identity_2eproto, "identity.proto",
	+ &descriptor_table_identity_2eproto_once, nullptr, 0, 13,
	+ schemas, file_default_instances, TableStruct_identity_2eproto::offsets,
	+ file_level_metadata_identity_2eproto, file_level_enum_descriptors_identity_2eproto, file_level_service_descriptors_identity_2eproto,
	+};
	+PROTOBUF_ATTRIBUTE_WEAK ::PROTOBUF_NAMESPACE_ID::Metadata
	+descriptor_table_identity_2eproto_metadata_getter(int index) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_identity_2eproto);
	+ return descriptor_table_identity_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_identity_2eproto(&descriptor_table_identity_2eproto);
	+namespace identity {
	+
	+// ===================================================================
	+
	+class PakeRegistrationRequestAndUserID::_Internal {
	+ public:
	+};
	+
	+PakeRegistrationRequestAndUserID::PakeRegistrationRequestAndUserID(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.PakeRegistrationRequestAndUserID)
	+}
	+PakeRegistrationRequestAndUserID::PakeRegistrationRequestAndUserID(const PakeRegistrationRequestAndUserID& 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());
	+ }
	+ deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_deviceid().empty()) {
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceid(),
	+ GetArena());
	+ }
	+ pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_pakeregistrationrequest().empty()) {
	+ pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakeregistrationrequest(),
	+ GetArena());
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.PakeRegistrationRequestAndUserID)
	+}
	+
	+void PakeRegistrationRequestAndUserID::SharedCtor() {
	+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+PakeRegistrationRequestAndUserID::~PakeRegistrationRequestAndUserID() {
	+ // @@protoc_insertion_point(destructor:identity.PakeRegistrationRequestAndUserID)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void PakeRegistrationRequestAndUserID::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ pakeregistrationrequest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+void PakeRegistrationRequestAndUserID::ArenaDtor(void* object) {
	+ PakeRegistrationRequestAndUserID* _this = reinterpret_cast< PakeRegistrationRequestAndUserID* >(object);
	+ (void)_this;
	+}
	+void PakeRegistrationRequestAndUserID::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void PakeRegistrationRequestAndUserID::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void PakeRegistrationRequestAndUserID::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.PakeRegistrationRequestAndUserID)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ userid_.ClearToEmpty();
	+ deviceid_.ClearToEmpty();
	+ pakeregistrationrequest_.ClearToEmpty();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* PakeRegistrationRequestAndUserID::_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;
	+ 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, "identity.PakeRegistrationRequestAndUserID.userID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string deviceID = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_deviceid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.PakeRegistrationRequestAndUserID.deviceID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes pakeRegistrationRequest = 3;
	+ case 3:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ auto str = _internal_mutable_pakeregistrationrequest();
	+ 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* PakeRegistrationRequestAndUserID::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.PakeRegistrationRequestAndUserID)
	+ ::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,
	+ "identity.PakeRegistrationRequestAndUserID.userID");
	+ target = stream->WriteStringMaybeAliased(
	+ 1, this->_internal_userid(), target);
	+ }
	+
	+ // string deviceID = 2;
	+ if (this->deviceid().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_deviceid().data(), static_cast<int>(this->_internal_deviceid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "identity.PakeRegistrationRequestAndUserID.deviceID");
	+ target = stream->WriteStringMaybeAliased(
	+ 2, this->_internal_deviceid(), target);
	+ }
	+
	+ // bytes pakeRegistrationRequest = 3;
	+ if (this->pakeregistrationrequest().size() > 0) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 3, this->_internal_pakeregistrationrequest(), 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:identity.PakeRegistrationRequestAndUserID)
	+ return target;
	+}
	+
	+size_t PakeRegistrationRequestAndUserID::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.PakeRegistrationRequestAndUserID)
	+ 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());
	+ }
	+
	+ // string deviceID = 2;
	+ if (this->deviceid().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_deviceid());
	+ }
	+
	+ // bytes pakeRegistrationRequest = 3;
	+ if (this->pakeregistrationrequest().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakeregistrationrequest());
	+ }
	+
	+ 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 PakeRegistrationRequestAndUserID::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.PakeRegistrationRequestAndUserID)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const PakeRegistrationRequestAndUserID* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeRegistrationRequestAndUserID>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.PakeRegistrationRequestAndUserID)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.PakeRegistrationRequestAndUserID)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void PakeRegistrationRequestAndUserID::MergeFrom(const PakeRegistrationRequestAndUserID& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.PakeRegistrationRequestAndUserID)
	+ 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.deviceid().size() > 0) {
	+ _internal_set_deviceid(from._internal_deviceid());
	+ }
	+ if (from.pakeregistrationrequest().size() > 0) {
	+ _internal_set_pakeregistrationrequest(from._internal_pakeregistrationrequest());
	+ }
	+}
	+
	+void PakeRegistrationRequestAndUserID::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.PakeRegistrationRequestAndUserID)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void PakeRegistrationRequestAndUserID::CopyFrom(const PakeRegistrationRequestAndUserID& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.PakeRegistrationRequestAndUserID)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool PakeRegistrationRequestAndUserID::IsInitialized() const {
	+ return true;
	+}
	+
	+void PakeRegistrationRequestAndUserID::InternalSwap(PakeRegistrationRequestAndUserID* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ pakeregistrationrequest_.Swap(&other->pakeregistrationrequest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata PakeRegistrationRequestAndUserID::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class PakeCredentialRequestAndUserID::_Internal {
	+ public:
	+};
	+
	+PakeCredentialRequestAndUserID::PakeCredentialRequestAndUserID(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.PakeCredentialRequestAndUserID)
	+}
	+PakeCredentialRequestAndUserID::PakeCredentialRequestAndUserID(const PakeCredentialRequestAndUserID& 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());
	+ }
	+ deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_deviceid().empty()) {
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceid(),
	+ GetArena());
	+ }
	+ pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_pakecredentialrequest().empty()) {
	+ pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakecredentialrequest(),
	+ GetArena());
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.PakeCredentialRequestAndUserID)
	+}
	+
	+void PakeCredentialRequestAndUserID::SharedCtor() {
	+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+PakeCredentialRequestAndUserID::~PakeCredentialRequestAndUserID() {
	+ // @@protoc_insertion_point(destructor:identity.PakeCredentialRequestAndUserID)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void PakeCredentialRequestAndUserID::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ pakecredentialrequest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+void PakeCredentialRequestAndUserID::ArenaDtor(void* object) {
	+ PakeCredentialRequestAndUserID* _this = reinterpret_cast< PakeCredentialRequestAndUserID* >(object);
	+ (void)_this;
	+}
	+void PakeCredentialRequestAndUserID::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void PakeCredentialRequestAndUserID::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void PakeCredentialRequestAndUserID::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.PakeCredentialRequestAndUserID)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ userid_.ClearToEmpty();
	+ deviceid_.ClearToEmpty();
	+ pakecredentialrequest_.ClearToEmpty();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* PakeCredentialRequestAndUserID::_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;
	+ 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, "identity.PakeCredentialRequestAndUserID.userID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string deviceID = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_deviceid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.PakeCredentialRequestAndUserID.deviceID"));
	+ 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;
	+ 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* PakeCredentialRequestAndUserID::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.PakeCredentialRequestAndUserID)
	+ ::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,
	+ "identity.PakeCredentialRequestAndUserID.userID");
	+ target = stream->WriteStringMaybeAliased(
	+ 1, this->_internal_userid(), target);
	+ }
	+
	+ // string deviceID = 2;
	+ if (this->deviceid().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_deviceid().data(), static_cast<int>(this->_internal_deviceid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "identity.PakeCredentialRequestAndUserID.deviceID");
	+ target = stream->WriteStringMaybeAliased(
	+ 2, this->_internal_deviceid(), target);
	+ }
	+
	+ // bytes pakeCredentialRequest = 3;
	+ if (this->pakecredentialrequest().size() > 0) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 3, this->_internal_pakecredentialrequest(), 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:identity.PakeCredentialRequestAndUserID)
	+ return target;
	+}
	+
	+size_t PakeCredentialRequestAndUserID::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.PakeCredentialRequestAndUserID)
	+ 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());
	+ }
	+
	+ // string deviceID = 2;
	+ if (this->deviceid().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_deviceid());
	+ }
	+
	+ // bytes pakeCredentialRequest = 3;
	+ if (this->pakecredentialrequest().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakecredentialrequest());
	+ }
	+
	+ 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 PakeCredentialRequestAndUserID::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.PakeCredentialRequestAndUserID)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const PakeCredentialRequestAndUserID* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeCredentialRequestAndUserID>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.PakeCredentialRequestAndUserID)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.PakeCredentialRequestAndUserID)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void PakeCredentialRequestAndUserID::MergeFrom(const PakeCredentialRequestAndUserID& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.PakeCredentialRequestAndUserID)
	+ 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.deviceid().size() > 0) {
	+ _internal_set_deviceid(from._internal_deviceid());
	+ }
	+ if (from.pakecredentialrequest().size() > 0) {
	+ _internal_set_pakecredentialrequest(from._internal_pakecredentialrequest());
	+ }
	+}
	+
	+void PakeCredentialRequestAndUserID::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.PakeCredentialRequestAndUserID)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void PakeCredentialRequestAndUserID::CopyFrom(const PakeCredentialRequestAndUserID& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.PakeCredentialRequestAndUserID)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool PakeCredentialRequestAndUserID::IsInitialized() const {
	+ return true;
	+}
	+
	+void PakeCredentialRequestAndUserID::InternalSwap(PakeCredentialRequestAndUserID* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ pakecredentialrequest_.Swap(&other->pakecredentialrequest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata PakeCredentialRequestAndUserID::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class PakeLoginRequest::_Internal {
	+ public:
	+ static const ::identity::PakeCredentialRequestAndUserID& pakecredentialrequestanduserid(const PakeLoginRequest* msg);
	+};
	+
	+const ::identity::PakeCredentialRequestAndUserID&
	+PakeLoginRequest::_Internal::pakecredentialrequestanduserid(const PakeLoginRequest* msg) {
	+ return *msg->data_.pakecredentialrequestanduserid_;
	+}
	+void PakeLoginRequest::set_allocated_pakecredentialrequestanduserid(::identity::PakeCredentialRequestAndUserID* pakecredentialrequestanduserid) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (pakecredentialrequestanduserid) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakecredentialrequestanduserid);
	+ if (message_arena != submessage_arena) {
	+ pakecredentialrequestanduserid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, pakecredentialrequestanduserid, submessage_arena);
	+ }
	+ set_has_pakecredentialrequestanduserid();
	+ data_.pakecredentialrequestanduserid_ = pakecredentialrequestanduserid;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
	+}
	+PakeLoginRequest::PakeLoginRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.PakeLoginRequest)
	+}
	+PakeLoginRequest::PakeLoginRequest(const PakeLoginRequest& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ clear_has_data();
	+ switch (from.data_case()) {
	+ case kPakeCredentialRequestAndUserID: {
	+ _internal_mutable_pakecredentialrequestanduserid()->::identity::PakeCredentialRequestAndUserID::MergeFrom(from._internal_pakecredentialrequestanduserid());
	+ break;
	+ }
	+ case kPakeCredentialFinalization: {
	+ _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.PakeLoginRequest)
	+}
	+
	+void PakeLoginRequest::SharedCtor() {
	+clear_has_data();
	+}
	+
	+PakeLoginRequest::~PakeLoginRequest() {
	+ // @@protoc_insertion_point(destructor:identity.PakeLoginRequest)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void PakeLoginRequest::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ if (has_data()) {
	+ clear_data();
	+ }
	+}
	+
	+void PakeLoginRequest::ArenaDtor(void* object) {
	+ PakeLoginRequest* _this = reinterpret_cast< PakeLoginRequest* >(object);
	+ (void)_this;
	+}
	+void PakeLoginRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void PakeLoginRequest::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void PakeLoginRequest::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:identity.PakeLoginRequest)
	+ switch (data_case()) {
	+ case kPakeCredentialRequestAndUserID: {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakecredentialrequestanduserid_;
	+ }
	+ break;
	+ }
	+ case kPakeCredentialFinalization: {
	+ data_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+
	+
	+void PakeLoginRequest::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.PakeLoginRequest)
	+ ::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* PakeLoginRequest::_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) {
	+ // .identity.PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_pakecredentialrequestanduserid(), ptr);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes pakeCredentialFinalization = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_pakecredentialfinalization();
	+ 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* PakeLoginRequest::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.PakeLoginRequest)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // .identity.PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
	+ if (_internal_has_pakecredentialrequestanduserid()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 1, _Internal::pakecredentialrequestanduserid(this), target, stream);
	+ }
	+
	+ // bytes pakeCredentialFinalization = 2;
	+ if (_internal_has_pakecredentialfinalization()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 2, this->_internal_pakecredentialfinalization(), 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:identity.PakeLoginRequest)
	+ return target;
	+}
	+
	+size_t PakeLoginRequest::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.PakeLoginRequest)
	+ 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()) {
	+ // .identity.PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
	+ case kPakeCredentialRequestAndUserID: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.pakecredentialrequestanduserid_);
	+ break;
	+ }
	+ // bytes pakeCredentialFinalization = 2;
	+ case kPakeCredentialFinalization: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakecredentialfinalization());
	+ 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 PakeLoginRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.PakeLoginRequest)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const PakeLoginRequest* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeLoginRequest>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.PakeLoginRequest)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.PakeLoginRequest)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void PakeLoginRequest::MergeFrom(const PakeLoginRequest& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.PakeLoginRequest)
	+ 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 kPakeCredentialRequestAndUserID: {
	+ _internal_mutable_pakecredentialrequestanduserid()->::identity::PakeCredentialRequestAndUserID::MergeFrom(from._internal_pakecredentialrequestanduserid());
	+ break;
	+ }
	+ case kPakeCredentialFinalization: {
	+ _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+}
	+
	+void PakeLoginRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.PakeLoginRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void PakeLoginRequest::CopyFrom(const PakeLoginRequest& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.PakeLoginRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool PakeLoginRequest::IsInitialized() const {
	+ return true;
	+}
	+
	+void PakeLoginRequest::InternalSwap(PakeLoginRequest* 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 PakeLoginRequest::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class PakeLoginResponse::_Internal {
	+ public:
	+};
	+
	+PakeLoginResponse::PakeLoginResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.PakeLoginResponse)
	+}
	+PakeLoginResponse::PakeLoginResponse(const PakeLoginResponse& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ clear_has_data();
	+ switch (from.data_case()) {
	+ case kPakeCredentialResponse: {
	+ _internal_set_pakecredentialresponse(from._internal_pakecredentialresponse());
	+ break;
	+ }
	+ case kAccessToken: {
	+ _internal_set_accesstoken(from._internal_accesstoken());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.PakeLoginResponse)
	+}
	+
	+void PakeLoginResponse::SharedCtor() {
	+clear_has_data();
	+}
	+
	+PakeLoginResponse::~PakeLoginResponse() {
	+ // @@protoc_insertion_point(destructor:identity.PakeLoginResponse)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void PakeLoginResponse::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ if (has_data()) {
	+ clear_data();
	+ }
	+}
	+
	+void PakeLoginResponse::ArenaDtor(void* object) {
	+ PakeLoginResponse* _this = reinterpret_cast< PakeLoginResponse* >(object);
	+ (void)_this;
	+}
	+void PakeLoginResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void PakeLoginResponse::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void PakeLoginResponse::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:identity.PakeLoginResponse)
	+ switch (data_case()) {
	+ case kPakeCredentialResponse: {
	+ data_.pakecredentialresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kAccessToken: {
	+ data_.accesstoken_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+
	+
	+void PakeLoginResponse::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.PakeLoginResponse)
	+ ::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* PakeLoginResponse::_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 pakeCredentialResponse = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ auto str = _internal_mutable_pakecredentialresponse();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string accessToken = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_accesstoken();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.PakeLoginResponse.accessToken"));
	+ 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* PakeLoginResponse::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.PakeLoginResponse)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // bytes pakeCredentialResponse = 1;
	+ if (_internal_has_pakecredentialresponse()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 1, this->_internal_pakecredentialresponse(), target);
	+ }
	+
	+ // string accessToken = 2;
	+ if (_internal_has_accesstoken()) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_accesstoken().data(), static_cast<int>(this->_internal_accesstoken().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "identity.PakeLoginResponse.accessToken");
	+ target = stream->WriteStringMaybeAliased(
	+ 2, this->_internal_accesstoken(), 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:identity.PakeLoginResponse)
	+ return target;
	+}
	+
	+size_t PakeLoginResponse::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.PakeLoginResponse)
	+ 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 pakeCredentialResponse = 1;
	+ case kPakeCredentialResponse: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakecredentialresponse());
	+ break;
	+ }
	+ // string accessToken = 2;
	+ case kAccessToken: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_accesstoken());
	+ 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 PakeLoginResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.PakeLoginResponse)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const PakeLoginResponse* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeLoginResponse>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.PakeLoginResponse)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.PakeLoginResponse)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void PakeLoginResponse::MergeFrom(const PakeLoginResponse& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.PakeLoginResponse)
	+ 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 kPakeCredentialResponse: {
	+ _internal_set_pakecredentialresponse(from._internal_pakecredentialresponse());
	+ break;
	+ }
	+ case kAccessToken: {
	+ _internal_set_accesstoken(from._internal_accesstoken());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+}
	+
	+void PakeLoginResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.PakeLoginResponse)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void PakeLoginResponse::CopyFrom(const PakeLoginResponse& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.PakeLoginResponse)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool PakeLoginResponse::IsInitialized() const {
	+ return true;
	+}
	+
	+void PakeLoginResponse::InternalSwap(PakeLoginResponse* 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 PakeLoginResponse::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class PakeRegistrationUploadAndCredentialRequest::_Internal {
	+ public:
	+};
	+
	+PakeRegistrationUploadAndCredentialRequest::PakeRegistrationUploadAndCredentialRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.PakeRegistrationUploadAndCredentialRequest)
	+}
	+PakeRegistrationUploadAndCredentialRequest::PakeRegistrationUploadAndCredentialRequest(const PakeRegistrationUploadAndCredentialRequest& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_pakeregistrationupload().empty()) {
	+ pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakeregistrationupload(),
	+ GetArena());
	+ }
	+ pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_pakecredentialrequest().empty()) {
	+ pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakecredentialrequest(),
	+ GetArena());
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.PakeRegistrationUploadAndCredentialRequest)
	+}
	+
	+void PakeRegistrationUploadAndCredentialRequest::SharedCtor() {
	+pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+PakeRegistrationUploadAndCredentialRequest::~PakeRegistrationUploadAndCredentialRequest() {
	+ // @@protoc_insertion_point(destructor:identity.PakeRegistrationUploadAndCredentialRequest)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void PakeRegistrationUploadAndCredentialRequest::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ pakeregistrationupload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ pakecredentialrequest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+void PakeRegistrationUploadAndCredentialRequest::ArenaDtor(void* object) {
	+ PakeRegistrationUploadAndCredentialRequest* _this = reinterpret_cast< PakeRegistrationUploadAndCredentialRequest* >(object);
	+ (void)_this;
	+}
	+void PakeRegistrationUploadAndCredentialRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void PakeRegistrationUploadAndCredentialRequest::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void PakeRegistrationUploadAndCredentialRequest::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.PakeRegistrationUploadAndCredentialRequest)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ pakeregistrationupload_.ClearToEmpty();
	+ pakecredentialrequest_.ClearToEmpty();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* PakeRegistrationUploadAndCredentialRequest::_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 pakeRegistrationUpload = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ auto str = _internal_mutable_pakeregistrationupload();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes pakeCredentialRequest = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_pakecredentialrequest();
	+ 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* PakeRegistrationUploadAndCredentialRequest::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.PakeRegistrationUploadAndCredentialRequest)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // bytes pakeRegistrationUpload = 1;
	+ if (this->pakeregistrationupload().size() > 0) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 1, this->_internal_pakeregistrationupload(), target);
	+ }
	+
	+ // bytes pakeCredentialRequest = 2;
	+ if (this->pakecredentialrequest().size() > 0) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 2, this->_internal_pakecredentialrequest(), 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:identity.PakeRegistrationUploadAndCredentialRequest)
	+ return target;
	+}
	+
	+size_t PakeRegistrationUploadAndCredentialRequest::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.PakeRegistrationUploadAndCredentialRequest)
	+ 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 pakeRegistrationUpload = 1;
	+ if (this->pakeregistrationupload().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakeregistrationupload());
	+ }
	+
	+ // bytes pakeCredentialRequest = 2;
	+ if (this->pakecredentialrequest().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakecredentialrequest());
	+ }
	+
	+ 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 PakeRegistrationUploadAndCredentialRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.PakeRegistrationUploadAndCredentialRequest)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const PakeRegistrationUploadAndCredentialRequest* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeRegistrationUploadAndCredentialRequest>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.PakeRegistrationUploadAndCredentialRequest)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.PakeRegistrationUploadAndCredentialRequest)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void PakeRegistrationUploadAndCredentialRequest::MergeFrom(const PakeRegistrationUploadAndCredentialRequest& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.PakeRegistrationUploadAndCredentialRequest)
	+ 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.pakeregistrationupload().size() > 0) {
	+ _internal_set_pakeregistrationupload(from._internal_pakeregistrationupload());
	+ }
	+ if (from.pakecredentialrequest().size() > 0) {
	+ _internal_set_pakecredentialrequest(from._internal_pakecredentialrequest());
	+ }
	+}
	+
	+void PakeRegistrationUploadAndCredentialRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.PakeRegistrationUploadAndCredentialRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void PakeRegistrationUploadAndCredentialRequest::CopyFrom(const PakeRegistrationUploadAndCredentialRequest& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.PakeRegistrationUploadAndCredentialRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool PakeRegistrationUploadAndCredentialRequest::IsInitialized() const {
	+ return true;
	+}
	+
	+void PakeRegistrationUploadAndCredentialRequest::InternalSwap(PakeRegistrationUploadAndCredentialRequest* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ pakeregistrationupload_.Swap(&other->pakeregistrationupload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ pakecredentialrequest_.Swap(&other->pakecredentialrequest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata PakeRegistrationUploadAndCredentialRequest::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class WalletLoginRequest::_Internal {
	+ public:
	+};
	+
	+WalletLoginRequest::WalletLoginRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.WalletLoginRequest)
	+}
	+WalletLoginRequest::WalletLoginRequest(const WalletLoginRequest& 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());
	+ }
	+ deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_deviceid().empty()) {
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceid(),
	+ GetArena());
	+ }
	+ siwemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_siwemessage().empty()) {
	+ siwemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_siwemessage(),
	+ GetArena());
	+ }
	+ siwesignature_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_siwesignature().empty()) {
	+ siwesignature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_siwesignature(),
	+ GetArena());
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.WalletLoginRequest)
	+}
	+
	+void WalletLoginRequest::SharedCtor() {
	+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+siwemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+siwesignature_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+WalletLoginRequest::~WalletLoginRequest() {
	+ // @@protoc_insertion_point(destructor:identity.WalletLoginRequest)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void WalletLoginRequest::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ siwemessage_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ siwesignature_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+void WalletLoginRequest::ArenaDtor(void* object) {
	+ WalletLoginRequest* _this = reinterpret_cast< WalletLoginRequest* >(object);
	+ (void)_this;
	+}
	+void WalletLoginRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void WalletLoginRequest::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void WalletLoginRequest::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.WalletLoginRequest)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ userid_.ClearToEmpty();
	+ deviceid_.ClearToEmpty();
	+ siwemessage_.ClearToEmpty();
	+ siwesignature_.ClearToEmpty();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* WalletLoginRequest::_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;
	+ 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, "identity.WalletLoginRequest.userID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string deviceID = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_deviceid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.WalletLoginRequest.deviceID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string siweMessage = 3;
	+ case 3:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ auto str = _internal_mutable_siwemessage();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.WalletLoginRequest.siweMessage"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes siweSignature = 4;
	+ case 4:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
	+ auto str = _internal_mutable_siwesignature();
	+ 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* WalletLoginRequest::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.WalletLoginRequest)
	+ ::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,
	+ "identity.WalletLoginRequest.userID");
	+ target = stream->WriteStringMaybeAliased(
	+ 1, this->_internal_userid(), target);
	+ }
	+
	+ // string deviceID = 2;
	+ if (this->deviceid().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_deviceid().data(), static_cast<int>(this->_internal_deviceid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "identity.WalletLoginRequest.deviceID");
	+ target = stream->WriteStringMaybeAliased(
	+ 2, this->_internal_deviceid(), target);
	+ }
	+
	+ // string siweMessage = 3;
	+ if (this->siwemessage().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_siwemessage().data(), static_cast<int>(this->_internal_siwemessage().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "identity.WalletLoginRequest.siweMessage");
	+ target = stream->WriteStringMaybeAliased(
	+ 3, this->_internal_siwemessage(), target);
	+ }
	+
	+ // bytes siweSignature = 4;
	+ if (this->siwesignature().size() > 0) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 4, this->_internal_siwesignature(), 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:identity.WalletLoginRequest)
	+ return target;
	+}
	+
	+size_t WalletLoginRequest::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.WalletLoginRequest)
	+ 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());
	+ }
	+
	+ // string deviceID = 2;
	+ if (this->deviceid().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_deviceid());
	+ }
	+
	+ // string siweMessage = 3;
	+ if (this->siwemessage().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_siwemessage());
	+ }
	+
	+ // bytes siweSignature = 4;
	+ if (this->siwesignature().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_siwesignature());
	+ }
	+
	+ 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 WalletLoginRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.WalletLoginRequest)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const WalletLoginRequest* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<WalletLoginRequest>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.WalletLoginRequest)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.WalletLoginRequest)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void WalletLoginRequest::MergeFrom(const WalletLoginRequest& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.WalletLoginRequest)
	+ 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.deviceid().size() > 0) {
	+ _internal_set_deviceid(from._internal_deviceid());
	+ }
	+ if (from.siwemessage().size() > 0) {
	+ _internal_set_siwemessage(from._internal_siwemessage());
	+ }
	+ if (from.siwesignature().size() > 0) {
	+ _internal_set_siwesignature(from._internal_siwesignature());
	+ }
	+}
	+
	+void WalletLoginRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.WalletLoginRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void WalletLoginRequest::CopyFrom(const WalletLoginRequest& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.WalletLoginRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool WalletLoginRequest::IsInitialized() const {
	+ return true;
	+}
	+
	+void WalletLoginRequest::InternalSwap(WalletLoginRequest* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ siwemessage_.Swap(&other->siwemessage_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ siwesignature_.Swap(&other->siwesignature_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata WalletLoginRequest::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class WalletLoginResponse::_Internal {
	+ public:
	+};
	+
	+WalletLoginResponse::WalletLoginResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.WalletLoginResponse)
	+}
	+WalletLoginResponse::WalletLoginResponse(const WalletLoginResponse& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_accesstoken().empty()) {
	+ accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_accesstoken(),
	+ GetArena());
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.WalletLoginResponse)
	+}
	+
	+void WalletLoginResponse::SharedCtor() {
	+accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+WalletLoginResponse::~WalletLoginResponse() {
	+ // @@protoc_insertion_point(destructor:identity.WalletLoginResponse)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void WalletLoginResponse::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ accesstoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+void WalletLoginResponse::ArenaDtor(void* object) {
	+ WalletLoginResponse* _this = reinterpret_cast< WalletLoginResponse* >(object);
	+ (void)_this;
	+}
	+void WalletLoginResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void WalletLoginResponse::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void WalletLoginResponse::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.WalletLoginResponse)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ accesstoken_.ClearToEmpty();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* WalletLoginResponse::_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 accessToken = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ auto str = _internal_mutable_accesstoken();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.WalletLoginResponse.accessToken"));
	+ 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* WalletLoginResponse::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.WalletLoginResponse)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // string accessToken = 1;
	+ if (this->accesstoken().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_accesstoken().data(), static_cast<int>(this->_internal_accesstoken().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "identity.WalletLoginResponse.accessToken");
	+ target = stream->WriteStringMaybeAliased(
	+ 1, this->_internal_accesstoken(), 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:identity.WalletLoginResponse)
	+ return target;
	+}
	+
	+size_t WalletLoginResponse::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.WalletLoginResponse)
	+ 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 accessToken = 1;
	+ if (this->accesstoken().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_accesstoken());
	+ }
	+
	+ 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 WalletLoginResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.WalletLoginResponse)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const WalletLoginResponse* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<WalletLoginResponse>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.WalletLoginResponse)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.WalletLoginResponse)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void WalletLoginResponse::MergeFrom(const WalletLoginResponse& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.WalletLoginResponse)
	+ 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.accesstoken().size() > 0) {
	+ _internal_set_accesstoken(from._internal_accesstoken());
	+ }
	+}
	+
	+void WalletLoginResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.WalletLoginResponse)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void WalletLoginResponse::CopyFrom(const WalletLoginResponse& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.WalletLoginResponse)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool WalletLoginResponse::IsInitialized() const {
	+ return true;
	+}
	+
	+void WalletLoginResponse::InternalSwap(WalletLoginResponse* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ accesstoken_.Swap(&other->accesstoken_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata WalletLoginResponse::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class RegistrationRequest::_Internal {
	+ public:
	+ static const ::identity::PakeRegistrationRequestAndUserID& pakeregistrationrequestanduserid(const RegistrationRequest* msg);
	+ static const ::identity::PakeRegistrationUploadAndCredentialRequest& pakeregistrationuploadandcredentialrequest(const RegistrationRequest* msg);
	+};
	+
	+const ::identity::PakeRegistrationRequestAndUserID&
	+RegistrationRequest::_Internal::pakeregistrationrequestanduserid(const RegistrationRequest* msg) {
	+ return *msg->data_.pakeregistrationrequestanduserid_;
	+}
	+const ::identity::PakeRegistrationUploadAndCredentialRequest&
	+RegistrationRequest::_Internal::pakeregistrationuploadandcredentialrequest(const RegistrationRequest* msg) {
	+ return *msg->data_.pakeregistrationuploadandcredentialrequest_;
	+}
	+void RegistrationRequest::set_allocated_pakeregistrationrequestanduserid(::identity::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (pakeregistrationrequestanduserid) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeregistrationrequestanduserid);
	+ if (message_arena != submessage_arena) {
	+ pakeregistrationrequestanduserid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, pakeregistrationrequestanduserid, submessage_arena);
	+ }
	+ set_has_pakeregistrationrequestanduserid();
	+ data_.pakeregistrationrequestanduserid_ = pakeregistrationrequestanduserid;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
	+}
	+void RegistrationRequest::set_allocated_pakeregistrationuploadandcredentialrequest(::identity::PakeRegistrationUploadAndCredentialRequest* pakeregistrationuploadandcredentialrequest) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (pakeregistrationuploadandcredentialrequest) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeregistrationuploadandcredentialrequest);
	+ if (message_arena != submessage_arena) {
	+ pakeregistrationuploadandcredentialrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, pakeregistrationuploadandcredentialrequest, submessage_arena);
	+ }
	+ set_has_pakeregistrationuploadandcredentialrequest();
	+ data_.pakeregistrationuploadandcredentialrequest_ = pakeregistrationuploadandcredentialrequest;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
	+}
	+RegistrationRequest::RegistrationRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.RegistrationRequest)
	+}
	+RegistrationRequest::RegistrationRequest(const RegistrationRequest& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ clear_has_data();
	+ switch (from.data_case()) {
	+ case kPakeRegistrationRequestAndUserID: {
	+ _internal_mutable_pakeregistrationrequestanduserid()->::identity::PakeRegistrationRequestAndUserID::MergeFrom(from._internal_pakeregistrationrequestanduserid());
	+ break;
	+ }
	+ case kPakeRegistrationUploadAndCredentialRequest: {
	+ _internal_mutable_pakeregistrationuploadandcredentialrequest()->::identity::PakeRegistrationUploadAndCredentialRequest::MergeFrom(from._internal_pakeregistrationuploadandcredentialrequest());
	+ break;
	+ }
	+ case kPakeCredentialFinalization: {
	+ _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.RegistrationRequest)
	+}
	+
	+void RegistrationRequest::SharedCtor() {
	+clear_has_data();
	+}
	+
	+RegistrationRequest::~RegistrationRequest() {
	+ // @@protoc_insertion_point(destructor:identity.RegistrationRequest)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void RegistrationRequest::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ if (has_data()) {
	+ clear_data();
	+ }
	+}
	+
	+void RegistrationRequest::ArenaDtor(void* object) {
	+ RegistrationRequest* _this = reinterpret_cast< RegistrationRequest* >(object);
	+ (void)_this;
	+}
	+void RegistrationRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void RegistrationRequest::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void RegistrationRequest::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:identity.RegistrationRequest)
	+ switch (data_case()) {
	+ case kPakeRegistrationRequestAndUserID: {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakeregistrationrequestanduserid_;
	+ }
	+ break;
	+ }
	+ case kPakeRegistrationUploadAndCredentialRequest: {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakeregistrationuploadandcredentialrequest_;
	+ }
	+ break;
	+ }
	+ case kPakeCredentialFinalization: {
	+ data_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+
	+
	+void RegistrationRequest::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.RegistrationRequest)
	+ ::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* RegistrationRequest::_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) {
	+ // .identity.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_pakeregistrationrequestanduserid(), ptr);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // .identity.PakeRegistrationUploadAndCredentialRequest pakeRegistrationUploadAndCredentialRequest = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_pakeregistrationuploadandcredentialrequest(), ptr);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // bytes pakeCredentialFinalization = 3;
	+ case 3:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ auto str = _internal_mutable_pakecredentialfinalization();
	+ 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* RegistrationRequest::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.RegistrationRequest)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // .identity.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
	+ if (_internal_has_pakeregistrationrequestanduserid()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 1, _Internal::pakeregistrationrequestanduserid(this), target, stream);
	+ }
	+
	+ // .identity.PakeRegistrationUploadAndCredentialRequest pakeRegistrationUploadAndCredentialRequest = 2;
	+ if (_internal_has_pakeregistrationuploadandcredentialrequest()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 2, _Internal::pakeregistrationuploadandcredentialrequest(this), target, stream);
	+ }
	+
	+ // bytes pakeCredentialFinalization = 3;
	+ if (_internal_has_pakecredentialfinalization()) {
	+ target = stream->WriteBytesMaybeAliased(
	+ 3, this->_internal_pakecredentialfinalization(), 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:identity.RegistrationRequest)
	+ return target;
	+}
	+
	+size_t RegistrationRequest::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.RegistrationRequest)
	+ 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()) {
	+ // .identity.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
	+ case kPakeRegistrationRequestAndUserID: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.pakeregistrationrequestanduserid_);
	+ break;
	+ }
	+ // .identity.PakeRegistrationUploadAndCredentialRequest pakeRegistrationUploadAndCredentialRequest = 2;
	+ case kPakeRegistrationUploadAndCredentialRequest: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.pakeregistrationuploadandcredentialrequest_);
	+ break;
	+ }
	+ // bytes pakeCredentialFinalization = 3;
	+ case kPakeCredentialFinalization: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakecredentialfinalization());
	+ 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 RegistrationRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.RegistrationRequest)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const RegistrationRequest* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RegistrationRequest>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.RegistrationRequest)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.RegistrationRequest)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void RegistrationRequest::MergeFrom(const RegistrationRequest& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.RegistrationRequest)
	+ 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 kPakeRegistrationRequestAndUserID: {
	+ _internal_mutable_pakeregistrationrequestanduserid()->::identity::PakeRegistrationRequestAndUserID::MergeFrom(from._internal_pakeregistrationrequestanduserid());
	+ break;
	+ }
	+ case kPakeRegistrationUploadAndCredentialRequest: {
	+ _internal_mutable_pakeregistrationuploadandcredentialrequest()->::identity::PakeRegistrationUploadAndCredentialRequest::MergeFrom(from._internal_pakeregistrationuploadandcredentialrequest());
	+ break;
	+ }
	+ case kPakeCredentialFinalization: {
	+ _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+}
	+
	+void RegistrationRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.RegistrationRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void RegistrationRequest::CopyFrom(const RegistrationRequest& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.RegistrationRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool RegistrationRequest::IsInitialized() const {
	+ return true;
	+}
	+
	+void RegistrationRequest::InternalSwap(RegistrationRequest* 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 RegistrationRequest::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class RegistrationResponse::_Internal {
	+ public:
	+ static const ::identity::PakeLoginResponse& pakeloginresponse(const RegistrationResponse* msg);
	+};
	+
	+const ::identity::PakeLoginResponse&
	+RegistrationResponse::_Internal::pakeloginresponse(const RegistrationResponse* msg) {
	+ return *msg->data_.pakeloginresponse_;
	+}
	+void RegistrationResponse::set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (pakeloginresponse) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeloginresponse);
	+ if (message_arena != submessage_arena) {
	+ pakeloginresponse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, pakeloginresponse, submessage_arena);
	+ }
	+ set_has_pakeloginresponse();
	+ data_.pakeloginresponse_ = pakeloginresponse;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.RegistrationResponse.pakeLoginResponse)
	+}
	+RegistrationResponse::RegistrationResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.RegistrationResponse)
	+}
	+RegistrationResponse::RegistrationResponse(const RegistrationResponse& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ clear_has_data();
	+ switch (from.data_case()) {
	+ case kPakeRegistrationResponse: {
	+ _internal_set_pakeregistrationresponse(from._internal_pakeregistrationresponse());
	+ break;
	+ }
	+ case kPakeLoginResponse: {
	+ _internal_mutable_pakeloginresponse()->::identity::PakeLoginResponse::MergeFrom(from._internal_pakeloginresponse());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.RegistrationResponse)
	+}
	+
	+void RegistrationResponse::SharedCtor() {
	+clear_has_data();
	+}
	+
	+RegistrationResponse::~RegistrationResponse() {
	+ // @@protoc_insertion_point(destructor:identity.RegistrationResponse)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void RegistrationResponse::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ if (has_data()) {
	+ clear_data();
	+ }
	+}
	+
	+void RegistrationResponse::ArenaDtor(void* object) {
	+ RegistrationResponse* _this = reinterpret_cast< RegistrationResponse* >(object);
	+ (void)_this;
	+}
	+void RegistrationResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void RegistrationResponse::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void RegistrationResponse::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:identity.RegistrationResponse)
	+ switch (data_case()) {
	+ case kPakeRegistrationResponse: {
	+ data_.pakeregistrationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
	+ break;
	+ }
	+ case kPakeLoginResponse: {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakeloginresponse_;
	+ }
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+
	+
	+void RegistrationResponse::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.RegistrationResponse)
	+ ::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* RegistrationResponse::_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;
	+ // .identity.PakeLoginResponse pakeLoginResponse = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_pakeloginresponse(), ptr);
	+ 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* RegistrationResponse::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.RegistrationResponse)
	+ ::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);
	+ }
	+
	+ // .identity.PakeLoginResponse pakeLoginResponse = 2;
	+ if (_internal_has_pakeloginresponse()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 2, _Internal::pakeloginresponse(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:identity.RegistrationResponse)
	+ return target;
	+}
	+
	+size_t RegistrationResponse::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.RegistrationResponse)
	+ 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 pakeRegistrationResponse = 1;
	+ case kPakeRegistrationResponse: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
	+ this->_internal_pakeregistrationresponse());
	+ break;
	+ }
	+ // .identity.PakeLoginResponse pakeLoginResponse = 2;
	+ case kPakeLoginResponse: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.pakeloginresponse_);
	+ 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 RegistrationResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.RegistrationResponse)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const RegistrationResponse* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RegistrationResponse>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.RegistrationResponse)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.RegistrationResponse)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void RegistrationResponse::MergeFrom(const RegistrationResponse& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.RegistrationResponse)
	+ 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 kPakeRegistrationResponse: {
	+ _internal_set_pakeregistrationresponse(from._internal_pakeregistrationresponse());
	+ break;
	+ }
	+ case kPakeLoginResponse: {
	+ _internal_mutable_pakeloginresponse()->::identity::PakeLoginResponse::MergeFrom(from._internal_pakeloginresponse());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+}
	+
	+void RegistrationResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.RegistrationResponse)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void RegistrationResponse::CopyFrom(const RegistrationResponse& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.RegistrationResponse)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool RegistrationResponse::IsInitialized() const {
	+ return true;
	+}
	+
	+void RegistrationResponse::InternalSwap(RegistrationResponse* 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 RegistrationResponse::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class LoginRequest::_Internal {
	+ public:
	+ static const ::identity::PakeLoginRequest& pakeloginrequest(const LoginRequest* msg);
	+ static const ::identity::WalletLoginRequest& walletloginrequest(const LoginRequest* msg);
	+};
	+
	+const ::identity::PakeLoginRequest&
	+LoginRequest::_Internal::pakeloginrequest(const LoginRequest* msg) {
	+ return *msg->data_.pakeloginrequest_;
	+}
	+const ::identity::WalletLoginRequest&
	+LoginRequest::_Internal::walletloginrequest(const LoginRequest* msg) {
	+ return *msg->data_.walletloginrequest_;
	+}
	+void LoginRequest::set_allocated_pakeloginrequest(::identity::PakeLoginRequest* pakeloginrequest) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (pakeloginrequest) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeloginrequest);
	+ if (message_arena != submessage_arena) {
	+ pakeloginrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, pakeloginrequest, submessage_arena);
	+ }
	+ set_has_pakeloginrequest();
	+ data_.pakeloginrequest_ = pakeloginrequest;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.LoginRequest.pakeLoginRequest)
	+}
	+void LoginRequest::set_allocated_walletloginrequest(::identity::WalletLoginRequest* walletloginrequest) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (walletloginrequest) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(walletloginrequest);
	+ if (message_arena != submessage_arena) {
	+ walletloginrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, walletloginrequest, submessage_arena);
	+ }
	+ set_has_walletloginrequest();
	+ data_.walletloginrequest_ = walletloginrequest;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.LoginRequest.walletLoginRequest)
	+}
	+LoginRequest::LoginRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.LoginRequest)
	+}
	+LoginRequest::LoginRequest(const LoginRequest& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ clear_has_data();
	+ switch (from.data_case()) {
	+ case kPakeLoginRequest: {
	+ _internal_mutable_pakeloginrequest()->::identity::PakeLoginRequest::MergeFrom(from._internal_pakeloginrequest());
	+ break;
	+ }
	+ case kWalletLoginRequest: {
	+ _internal_mutable_walletloginrequest()->::identity::WalletLoginRequest::MergeFrom(from._internal_walletloginrequest());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.LoginRequest)
	+}
	+
	+void LoginRequest::SharedCtor() {
	+clear_has_data();
	+}
	+
	+LoginRequest::~LoginRequest() {
	+ // @@protoc_insertion_point(destructor:identity.LoginRequest)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void LoginRequest::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ if (has_data()) {
	+ clear_data();
	+ }
	+}
	+
	+void LoginRequest::ArenaDtor(void* object) {
	+ LoginRequest* _this = reinterpret_cast< LoginRequest* >(object);
	+ (void)_this;
	+}
	+void LoginRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void LoginRequest::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void LoginRequest::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:identity.LoginRequest)
	+ switch (data_case()) {
	+ case kPakeLoginRequest: {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakeloginrequest_;
	+ }
	+ break;
	+ }
	+ case kWalletLoginRequest: {
	+ if (GetArena() == nullptr) {
	+ delete data_.walletloginrequest_;
	+ }
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+
	+
	+void LoginRequest::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.LoginRequest)
	+ ::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* LoginRequest::_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) {
	+ // .identity.PakeLoginRequest pakeLoginRequest = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_pakeloginrequest(), ptr);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // .identity.WalletLoginRequest walletLoginRequest = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_walletloginrequest(), ptr);
	+ 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* LoginRequest::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.LoginRequest)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // .identity.PakeLoginRequest pakeLoginRequest = 1;
	+ if (_internal_has_pakeloginrequest()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 1, _Internal::pakeloginrequest(this), target, stream);
	+ }
	+
	+ // .identity.WalletLoginRequest walletLoginRequest = 2;
	+ if (_internal_has_walletloginrequest()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 2, _Internal::walletloginrequest(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:identity.LoginRequest)
	+ return target;
	+}
	+
	+size_t LoginRequest::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.LoginRequest)
	+ 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()) {
	+ // .identity.PakeLoginRequest pakeLoginRequest = 1;
	+ case kPakeLoginRequest: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.pakeloginrequest_);
	+ break;
	+ }
	+ // .identity.WalletLoginRequest walletLoginRequest = 2;
	+ case kWalletLoginRequest: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.walletloginrequest_);
	+ 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 LoginRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.LoginRequest)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const LoginRequest* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<LoginRequest>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.LoginRequest)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.LoginRequest)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void LoginRequest::MergeFrom(const LoginRequest& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.LoginRequest)
	+ 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 kPakeLoginRequest: {
	+ _internal_mutable_pakeloginrequest()->::identity::PakeLoginRequest::MergeFrom(from._internal_pakeloginrequest());
	+ break;
	+ }
	+ case kWalletLoginRequest: {
	+ _internal_mutable_walletloginrequest()->::identity::WalletLoginRequest::MergeFrom(from._internal_walletloginrequest());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+}
	+
	+void LoginRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.LoginRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void LoginRequest::CopyFrom(const LoginRequest& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.LoginRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool LoginRequest::IsInitialized() const {
	+ return true;
	+}
	+
	+void LoginRequest::InternalSwap(LoginRequest* 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 LoginRequest::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class LoginResponse::_Internal {
	+ public:
	+ static const ::identity::PakeLoginResponse& pakeloginresponse(const LoginResponse* msg);
	+ static const ::identity::WalletLoginResponse& walletloginresponse(const LoginResponse* msg);
	+};
	+
	+const ::identity::PakeLoginResponse&
	+LoginResponse::_Internal::pakeloginresponse(const LoginResponse* msg) {
	+ return *msg->data_.pakeloginresponse_;
	+}
	+const ::identity::WalletLoginResponse&
	+LoginResponse::_Internal::walletloginresponse(const LoginResponse* msg) {
	+ return *msg->data_.walletloginresponse_;
	+}
	+void LoginResponse::set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (pakeloginresponse) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeloginresponse);
	+ if (message_arena != submessage_arena) {
	+ pakeloginresponse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, pakeloginresponse, submessage_arena);
	+ }
	+ set_has_pakeloginresponse();
	+ data_.pakeloginresponse_ = pakeloginresponse;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.LoginResponse.pakeLoginResponse)
	+}
	+void LoginResponse::set_allocated_walletloginresponse(::identity::WalletLoginResponse* walletloginresponse) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
	+ clear_data();
	+ if (walletloginresponse) {
	+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
	+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(walletloginresponse);
	+ if (message_arena != submessage_arena) {
	+ walletloginresponse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
	+ message_arena, walletloginresponse, submessage_arena);
	+ }
	+ set_has_walletloginresponse();
	+ data_.walletloginresponse_ = walletloginresponse;
	+ }
	+ // @@protoc_insertion_point(field_set_allocated:identity.LoginResponse.walletLoginResponse)
	+}
	+LoginResponse::LoginResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.LoginResponse)
	+}
	+LoginResponse::LoginResponse(const LoginResponse& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ clear_has_data();
	+ switch (from.data_case()) {
	+ case kPakeLoginResponse: {
	+ _internal_mutable_pakeloginresponse()->::identity::PakeLoginResponse::MergeFrom(from._internal_pakeloginresponse());
	+ break;
	+ }
	+ case kWalletLoginResponse: {
	+ _internal_mutable_walletloginresponse()->::identity::WalletLoginResponse::MergeFrom(from._internal_walletloginresponse());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.LoginResponse)
	+}
	+
	+void LoginResponse::SharedCtor() {
	+clear_has_data();
	+}
	+
	+LoginResponse::~LoginResponse() {
	+ // @@protoc_insertion_point(destructor:identity.LoginResponse)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void LoginResponse::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ if (has_data()) {
	+ clear_data();
	+ }
	+}
	+
	+void LoginResponse::ArenaDtor(void* object) {
	+ LoginResponse* _this = reinterpret_cast< LoginResponse* >(object);
	+ (void)_this;
	+}
	+void LoginResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void LoginResponse::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void LoginResponse::clear_data() {
	+// @@protoc_insertion_point(one_of_clear_start:identity.LoginResponse)
	+ switch (data_case()) {
	+ case kPakeLoginResponse: {
	+ if (GetArena() == nullptr) {
	+ delete data_.pakeloginresponse_;
	+ }
	+ break;
	+ }
	+ case kWalletLoginResponse: {
	+ if (GetArena() == nullptr) {
	+ delete data_.walletloginresponse_;
	+ }
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+ _oneof_case_[0] = DATA_NOT_SET;
	+}
	+
	+
	+void LoginResponse::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.LoginResponse)
	+ ::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* LoginResponse::_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) {
	+ // .identity.PakeLoginResponse pakeLoginResponse = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_pakeloginresponse(), ptr);
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // .identity.WalletLoginResponse walletLoginResponse = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ ptr = ctx->ParseMessage(_internal_mutable_walletloginresponse(), ptr);
	+ 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* LoginResponse::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.LoginResponse)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // .identity.PakeLoginResponse pakeLoginResponse = 1;
	+ if (_internal_has_pakeloginresponse()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 1, _Internal::pakeloginresponse(this), target, stream);
	+ }
	+
	+ // .identity.WalletLoginResponse walletLoginResponse = 2;
	+ if (_internal_has_walletloginresponse()) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
	+ InternalWriteMessage(
	+ 2, _Internal::walletloginresponse(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:identity.LoginResponse)
	+ return target;
	+}
	+
	+size_t LoginResponse::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.LoginResponse)
	+ 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()) {
	+ // .identity.PakeLoginResponse pakeLoginResponse = 1;
	+ case kPakeLoginResponse: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.pakeloginresponse_);
	+ break;
	+ }
	+ // .identity.WalletLoginResponse walletLoginResponse = 2;
	+ case kWalletLoginResponse: {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
	+ *data_.walletloginresponse_);
	+ 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 LoginResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.LoginResponse)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const LoginResponse* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<LoginResponse>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.LoginResponse)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.LoginResponse)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void LoginResponse::MergeFrom(const LoginResponse& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.LoginResponse)
	+ 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 kPakeLoginResponse: {
	+ _internal_mutable_pakeloginresponse()->::identity::PakeLoginResponse::MergeFrom(from._internal_pakeloginresponse());
	+ break;
	+ }
	+ case kWalletLoginResponse: {
	+ _internal_mutable_walletloginresponse()->::identity::WalletLoginResponse::MergeFrom(from._internal_walletloginresponse());
	+ break;
	+ }
	+ case DATA_NOT_SET: {
	+ break;
	+ }
	+ }
	+}
	+
	+void LoginResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.LoginResponse)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void LoginResponse::CopyFrom(const LoginResponse& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.LoginResponse)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool LoginResponse::IsInitialized() const {
	+ return true;
	+}
	+
	+void LoginResponse::InternalSwap(LoginResponse* 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 LoginResponse::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class VerifyUserTokenRequest::_Internal {
	+ public:
	+};
	+
	+VerifyUserTokenRequest::VerifyUserTokenRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.VerifyUserTokenRequest)
	+}
	+VerifyUserTokenRequest::VerifyUserTokenRequest(const VerifyUserTokenRequest& 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());
	+ }
	+ deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_deviceid().empty()) {
	+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceid(),
	+ GetArena());
	+ }
	+ accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ if (!from._internal_accesstoken().empty()) {
	+ accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_accesstoken(),
	+ GetArena());
	+ }
	+ // @@protoc_insertion_point(copy_constructor:identity.VerifyUserTokenRequest)
	+}
	+
	+void VerifyUserTokenRequest::SharedCtor() {
	+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+VerifyUserTokenRequest::~VerifyUserTokenRequest() {
	+ // @@protoc_insertion_point(destructor:identity.VerifyUserTokenRequest)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void VerifyUserTokenRequest::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+ userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+ accesstoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	+}
	+
	+void VerifyUserTokenRequest::ArenaDtor(void* object) {
	+ VerifyUserTokenRequest* _this = reinterpret_cast< VerifyUserTokenRequest* >(object);
	+ (void)_this;
	+}
	+void VerifyUserTokenRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void VerifyUserTokenRequest::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void VerifyUserTokenRequest::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.VerifyUserTokenRequest)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ userid_.ClearToEmpty();
	+ deviceid_.ClearToEmpty();
	+ accesstoken_.ClearToEmpty();
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* VerifyUserTokenRequest::_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;
	+ 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, "identity.VerifyUserTokenRequest.userID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string deviceID = 2;
	+ case 2:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
	+ auto str = _internal_mutable_deviceid();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.VerifyUserTokenRequest.deviceID"));
	+ CHK_(ptr);
	+ } else goto handle_unusual;
	+ continue;
	+ // string accessToken = 3;
	+ case 3:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
	+ auto str = _internal_mutable_accesstoken();
	+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
	+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.VerifyUserTokenRequest.accessToken"));
	+ 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* VerifyUserTokenRequest::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.VerifyUserTokenRequest)
	+ ::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,
	+ "identity.VerifyUserTokenRequest.userID");
	+ target = stream->WriteStringMaybeAliased(
	+ 1, this->_internal_userid(), target);
	+ }
	+
	+ // string deviceID = 2;
	+ if (this->deviceid().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_deviceid().data(), static_cast<int>(this->_internal_deviceid().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "identity.VerifyUserTokenRequest.deviceID");
	+ target = stream->WriteStringMaybeAliased(
	+ 2, this->_internal_deviceid(), target);
	+ }
	+
	+ // string accessToken = 3;
	+ if (this->accesstoken().size() > 0) {
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
	+ this->_internal_accesstoken().data(), static_cast<int>(this->_internal_accesstoken().length()),
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
	+ "identity.VerifyUserTokenRequest.accessToken");
	+ target = stream->WriteStringMaybeAliased(
	+ 3, this->_internal_accesstoken(), 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:identity.VerifyUserTokenRequest)
	+ return target;
	+}
	+
	+size_t VerifyUserTokenRequest::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.VerifyUserTokenRequest)
	+ 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());
	+ }
	+
	+ // string deviceID = 2;
	+ if (this->deviceid().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_deviceid());
	+ }
	+
	+ // string accessToken = 3;
	+ if (this->accesstoken().size() > 0) {
	+ total_size += 1 +
	+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
	+ this->_internal_accesstoken());
	+ }
	+
	+ 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 VerifyUserTokenRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.VerifyUserTokenRequest)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const VerifyUserTokenRequest* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<VerifyUserTokenRequest>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.VerifyUserTokenRequest)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.VerifyUserTokenRequest)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void VerifyUserTokenRequest::MergeFrom(const VerifyUserTokenRequest& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.VerifyUserTokenRequest)
	+ 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.deviceid().size() > 0) {
	+ _internal_set_deviceid(from._internal_deviceid());
	+ }
	+ if (from.accesstoken().size() > 0) {
	+ _internal_set_accesstoken(from._internal_accesstoken());
	+ }
	+}
	+
	+void VerifyUserTokenRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.VerifyUserTokenRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void VerifyUserTokenRequest::CopyFrom(const VerifyUserTokenRequest& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.VerifyUserTokenRequest)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool VerifyUserTokenRequest::IsInitialized() const {
	+ return true;
	+}
	+
	+void VerifyUserTokenRequest::InternalSwap(VerifyUserTokenRequest* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+ accesstoken_.Swap(&other->accesstoken_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata VerifyUserTokenRequest::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// ===================================================================
	+
	+class VerifyUserTokenResponse::_Internal {
	+ public:
	+};
	+
	+VerifyUserTokenResponse::VerifyUserTokenResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
	+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
	+ SharedCtor();
	+ RegisterArenaDtor(arena);
	+ // @@protoc_insertion_point(arena_constructor:identity.VerifyUserTokenResponse)
	+}
	+VerifyUserTokenResponse::VerifyUserTokenResponse(const VerifyUserTokenResponse& from)
	+ : ::PROTOBUF_NAMESPACE_ID::Message() {
	+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
	+ tokenvalid_ = from.tokenvalid_;
	+ // @@protoc_insertion_point(copy_constructor:identity.VerifyUserTokenResponse)
	+}
	+
	+void VerifyUserTokenResponse::SharedCtor() {
	+tokenvalid_ = false;
	+}
	+
	+VerifyUserTokenResponse::~VerifyUserTokenResponse() {
	+ // @@protoc_insertion_point(destructor:identity.VerifyUserTokenResponse)
	+ SharedDtor();
	+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+void VerifyUserTokenResponse::SharedDtor() {
	+ GOOGLE_DCHECK(GetArena() == nullptr);
	+}
	+
	+void VerifyUserTokenResponse::ArenaDtor(void* object) {
	+ VerifyUserTokenResponse* _this = reinterpret_cast< VerifyUserTokenResponse* >(object);
	+ (void)_this;
	+}
	+void VerifyUserTokenResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
	+}
	+void VerifyUserTokenResponse::SetCachedSize(int size) const {
	+ _cached_size_.Set(size);
	+}
	+
	+void VerifyUserTokenResponse::Clear() {
	+// @@protoc_insertion_point(message_clear_start:identity.VerifyUserTokenResponse)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ // Prevent compiler warnings about cached_has_bits being unused
	+ (void) cached_has_bits;
	+
	+ tokenvalid_ = false;
	+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
	+}
	+
	+const char* VerifyUserTokenResponse::_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) {
	+ // bool tokenValid = 1;
	+ case 1:
	+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
	+ tokenvalid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
	+ 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* VerifyUserTokenResponse::_InternalSerialize(
	+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
	+ // @@protoc_insertion_point(serialize_to_array_start:identity.VerifyUserTokenResponse)
	+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
	+ (void) cached_has_bits;
	+
	+ // bool tokenValid = 1;
	+ if (this->tokenvalid() != 0) {
	+ target = stream->EnsureSpace(target);
	+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_tokenvalid(), 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:identity.VerifyUserTokenResponse)
	+ return target;
	+}
	+
	+size_t VerifyUserTokenResponse::ByteSizeLong() const {
	+// @@protoc_insertion_point(message_byte_size_start:identity.VerifyUserTokenResponse)
	+ 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;
	+
	+ // bool tokenValid = 1;
	+ if (this->tokenvalid() != 0) {
	+ total_size += 1 + 1;
	+ }
	+
	+ 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 VerifyUserTokenResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_merge_from_start:identity.VerifyUserTokenResponse)
	+ GOOGLE_DCHECK_NE(&from, this);
	+ const VerifyUserTokenResponse* source =
	+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<VerifyUserTokenResponse>(
	+ &from);
	+ if (source == nullptr) {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.VerifyUserTokenResponse)
	+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
	+ } else {
	+ // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.VerifyUserTokenResponse)
	+ MergeFrom(*source);
	+ }
	+}
	+
	+void VerifyUserTokenResponse::MergeFrom(const VerifyUserTokenResponse& from) {
	+// @@protoc_insertion_point(class_specific_merge_from_start:identity.VerifyUserTokenResponse)
	+ 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.tokenvalid() != 0) {
	+ _internal_set_tokenvalid(from._internal_tokenvalid());
	+ }
	+}
	+
	+void VerifyUserTokenResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
	+// @@protoc_insertion_point(generalized_copy_from_start:identity.VerifyUserTokenResponse)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+void VerifyUserTokenResponse::CopyFrom(const VerifyUserTokenResponse& from) {
	+// @@protoc_insertion_point(class_specific_copy_from_start:identity.VerifyUserTokenResponse)
	+ if (&from == this) return;
	+ Clear();
	+ MergeFrom(from);
	+}
	+
	+bool VerifyUserTokenResponse::IsInitialized() const {
	+ return true;
	+}
	+
	+void VerifyUserTokenResponse::InternalSwap(VerifyUserTokenResponse* other) {
	+ using std::swap;
	+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
	+ swap(tokenvalid_, other->tokenvalid_);
	+}
	+
	+::PROTOBUF_NAMESPACE_ID::Metadata VerifyUserTokenResponse::GetMetadata() const {
	+ return GetMetadataStatic();
	+}
	+
	+
	+// @@protoc_insertion_point(namespace_scope)
	+} // namespace identity
	+PROTOBUF_NAMESPACE_OPEN
	+template<> PROTOBUF_NOINLINE ::identity::PakeRegistrationRequestAndUserID* Arena::CreateMaybeMessage< ::identity::PakeRegistrationRequestAndUserID >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::PakeRegistrationRequestAndUserID >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::PakeCredentialRequestAndUserID* Arena::CreateMaybeMessage< ::identity::PakeCredentialRequestAndUserID >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::PakeCredentialRequestAndUserID >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::PakeLoginRequest* Arena::CreateMaybeMessage< ::identity::PakeLoginRequest >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::PakeLoginRequest >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::PakeLoginResponse* Arena::CreateMaybeMessage< ::identity::PakeLoginResponse >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::PakeLoginResponse >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::PakeRegistrationUploadAndCredentialRequest* Arena::CreateMaybeMessage< ::identity::PakeRegistrationUploadAndCredentialRequest >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::PakeRegistrationUploadAndCredentialRequest >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::WalletLoginRequest* Arena::CreateMaybeMessage< ::identity::WalletLoginRequest >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::WalletLoginRequest >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::WalletLoginResponse* Arena::CreateMaybeMessage< ::identity::WalletLoginResponse >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::WalletLoginResponse >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::RegistrationRequest* Arena::CreateMaybeMessage< ::identity::RegistrationRequest >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::RegistrationRequest >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::RegistrationResponse* Arena::CreateMaybeMessage< ::identity::RegistrationResponse >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::RegistrationResponse >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::LoginRequest* Arena::CreateMaybeMessage< ::identity::LoginRequest >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::LoginRequest >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::LoginResponse* Arena::CreateMaybeMessage< ::identity::LoginResponse >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::LoginResponse >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::VerifyUserTokenRequest* Arena::CreateMaybeMessage< ::identity::VerifyUserTokenRequest >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::VerifyUserTokenRequest >(arena);
	+}
	+template<> PROTOBUF_NOINLINE ::identity::VerifyUserTokenResponse* Arena::CreateMaybeMessage< ::identity::VerifyUserTokenResponse >(Arena* arena) {
	+ return Arena::CreateMessageInternal< ::identity::VerifyUserTokenResponse >(arena);
	+}
	+PROTOBUF_NAMESPACE_CLOSE
	+
	+// @@protoc_insertion_point(global_scope)
	+#include <google/protobuf/port_undef.inc>
	diff --git a/native/ios/Comm.xcodeproj/project.pbxproj b/native/ios/Comm.xcodeproj/project.pbxproj
	--- a/native/ios/Comm.xcodeproj/project.pbxproj
	+++ b/native/ios/Comm.xcodeproj/project.pbxproj
	@@ -12,6 +12,8 @@
	13B07FC11A68108700A75B9A /* main.m in Sources / = {isa = PBXBuildFile; fileRef = 13B07FB71A68108700A75B9A / main.m */; };
	1F537ACC7B60DC049C0ECFA7 /* ExpoModulesProvider.swift in Sources / = {isa = PBXBuildFile; fileRef = 769A87FB41BCE3FEF97FD59A / ExpoModulesProvider.swift */; };
	2DDA0AE067906E18B83A455C /* ClientGetReadReactor.cpp in Sources / = {isa = PBXBuildFile; fileRef = 2DDA00CA889DFF0ECB7E338D / ClientGetReadReactor.cpp */; };
	+ 6558B3022881F97C00A5DF85 /* identity.grpc.pb.cc in Sources / = {isa = PBXBuildFile; fileRef = 6558B2FF2881F97C00A5DF85 / identity.grpc.pb.cc */; };
	+ 6558B3032881F97C00A5DF85 /* identity.pb.cc in Sources / = {isa = PBXBuildFile; fileRef = 6558B3012881F97C00A5DF85 / identity.pb.cc */; };
	71009A7726FDCA67002C8453 /* tunnelbroker.pb.cc in Sources / = {isa = PBXBuildFile; fileRef = 71009A7326FDCA67002C8453 / tunnelbroker.pb.cc */; };
	71009A7826FDCA67002C8453 /* tunnelbroker.grpc.pb.cc in Sources / = {isa = PBXBuildFile; fileRef = 71009A7526FDCA67002C8453 / tunnelbroker.grpc.pb.cc */; };
	71009A7B26FDCD72002C8453 /* Client.cpp in Sources / = {isa = PBXBuildFile; fileRef = 71009A7926FDCD71002C8453 / Client.cpp */; };
	@@ -116,6 +118,10 @@
	2DDA0A22FECC9DAA5C19C35D /* Metadata.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Metadata.h; sourceTree = "<group>"; };
	3EE4DCB430B05EC9DE7D7B01 /* libPods-NotificationService.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-NotificationService.a"; sourceTree = BUILT_PRODUCTS_DIR; };
	3EEB3E70587B0ADAD05237B0 /* ExpoModulesProvider.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; name = ExpoModulesProvider.swift; path = "Pods/Target Support Files/Pods-Comm/ExpoModulesProvider.swift"; sourceTree = "<group>"; };
	+ 6558B2FE2881F97C00A5DF85 /* identity.pb.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = identity.pb.h; sourceTree = "<group>"; };
	+ 6558B2FF2881F97C00A5DF85 /* identity.grpc.pb.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = identity.grpc.pb.cc; sourceTree = "<group>"; };
	+ 6558B3002881F97C00A5DF85 /* identity.grpc.pb.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = identity.grpc.pb.h; sourceTree = "<group>"; };
	+ 6558B3012881F97C00A5DF85 /* identity.pb.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = identity.pb.cc; sourceTree = "<group>"; };
	71009A7326FDCA67002C8453 /* tunnelbroker.pb.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tunnelbroker.pb.cc; sourceTree = "<group>"; };
	71009A7426FDCA67002C8453 /* tunnelbroker.pb.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = tunnelbroker.pb.h; sourceTree = "<group>"; };
	71009A7526FDCA67002C8453 /* tunnelbroker.grpc.pb.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tunnelbroker.grpc.pb.cc; sourceTree = "<group>"; };
	@@ -319,6 +325,10 @@
	718A3C0626F22D0A00F04A8D /* _generated */ = {
	isa = PBXGroup;
	children = (
	+ 6558B2FF2881F97C00A5DF85 /* identity.grpc.pb.cc */,
	+ 6558B3002881F97C00A5DF85 /* identity.grpc.pb.h */,
	+ 6558B3012881F97C00A5DF85 /* identity.pb.cc */,
	+ 6558B2FE2881F97C00A5DF85 /* identity.pb.h */,
	71009A7526FDCA67002C8453 /* tunnelbroker.grpc.pb.cc */,
	71009A7626FDCA67002C8453 /* tunnelbroker.grpc.pb.h */,
	71009A7326FDCA67002C8453 /* tunnelbroker.pb.cc */,
	@@ -944,11 +954,13 @@
	71009A7B26FDCD72002C8453 /* Client.cpp in Sources */,
	71762A75270D8AAE00F565ED /* PlatformSpecificTools.mm in Sources */,
	71BF5B7126B3FF0900EDE27D /* Session.cpp in Sources */,
	+ 6558B3032881F97C00A5DF85 /* identity.pb.cc in Sources */,
	71009A7726FDCA67002C8453 /* tunnelbroker.pb.cc in Sources */,
	726E5D752731A4790032361D /* NetworkModule.cpp in Sources */,
	71BF5B7526B401D300EDE27D /* Tools.cpp in Sources */,
	13B07FBC1A68108700A75B9A /* AppDelegate.mm in Sources */,
	71142A7726C2650B0039DCBD /* CommSecureStoreIOSWrapper.mm in Sources */,
	+ 6558B3022881F97C00A5DF85 /* identity.grpc.pb.cc in Sources */,
	CB38F2B1286C6C870010535C /* MessageOperationsUtilities.cpp in Sources */,
	71BE84492636A944002849D2 /* NativeModules.cpp in Sources */,
	71CA4A64262DA8E500835C89 /* Logger.mm in Sources */,

File Metadata

Mime Type: text/plain
Expires: Sat, Dec 28, 5:44 AM (6 h, 23 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2711765
Default Alt Text: D4546.id.diff (445 KB)

D4546.id.diffNo OneTemporaryActions

D4546.id.diffView Options

File Metadata

Event Timeline

D4546.id.diff
No OneTemporary
Actions

D4546.id.diff
View Options